1 /* File IO for GNU Emacs.
3 Copyright (C) 1985-1988, 1993-2013 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
24 #include <sys/types.h>
34 #ifdef HAVE_LIBSELINUX
35 #include <selinux/selinux.h>
36 #include <selinux/context.h>
39 #ifdef HAVE_ACL_SET_FILE
46 #include "intervals.h"
47 #include "character.h"
51 #include "blockinput.h"
52 #include "region-cache.h"
54 #include "dispextern.h"
61 #endif /* not WINDOWSNT */
65 #include <sys/param.h>
69 /* On Windows, drive letters must be alphabetic - on DOS, the Netware
70 redirector allows the six letters between 'Z' and 'a' as well. */
72 #define IS_DRIVE(x) ((x) >= 'A' && (x) <= 'z')
75 #define IS_DRIVE(x) c_isalpha (x)
77 /* Need to lower-case the drive letter, or else expanded
78 filenames will sometimes compare unequal, because
79 `expand-file-name' doesn't always down-case the drive letter. */
80 #define DRIVE_LETTER(x) c_tolower (x)
85 #include <allocator.h>
86 #include <careadlinkat.h>
87 #include <stat-time.h>
95 /* True during writing of auto-save files. */
96 static bool auto_saving
;
98 /* Nonzero umask during creation of auto-save directories. */
99 static mode_t auto_saving_dir_umask
;
101 /* Set by auto_save_1 to mode of original file so Fwrite_region will create
102 a new file with the same mode as the original. */
103 static mode_t auto_save_mode_bits
;
105 /* Set by auto_save_1 if an error occurred during the last auto-save. */
106 static bool auto_save_error_occurred
;
108 /* If VALID_TIMESTAMP_FILE_SYSTEM, then TIMESTAMP_FILE_SYSTEM is the device
109 number of a file system where time stamps were observed to to work. */
110 static bool valid_timestamp_file_system
;
111 static dev_t timestamp_file_system
;
113 /* The symbol bound to coding-system-for-read when
114 insert-file-contents is called for recovering a file. This is not
115 an actual coding system name, but just an indicator to tell
116 insert-file-contents to use `emacs-mule' with a special flag for
117 auto saving and recovering a file. */
118 static Lisp_Object Qauto_save_coding
;
120 /* Property name of a file name handler,
121 which gives a list of operations it handles.. */
122 static Lisp_Object Qoperations
;
124 /* Lisp functions for translating file formats. */
125 static Lisp_Object Qformat_decode
, Qformat_annotate_function
;
127 /* Lisp function for setting buffer-file-coding-system and the
128 multibyteness of the current buffer after inserting a file. */
129 static Lisp_Object Qafter_insert_file_set_coding
;
131 static Lisp_Object Qwrite_region_annotate_functions
;
132 /* Each time an annotation function changes the buffer, the new buffer
134 static Lisp_Object Vwrite_region_annotation_buffers
;
136 static Lisp_Object Qdelete_by_moving_to_trash
;
138 /* Lisp function for moving files to trash. */
139 static Lisp_Object Qmove_file_to_trash
;
141 /* Lisp function for recursively copying directories. */
142 static Lisp_Object Qcopy_directory
;
144 /* Lisp function for recursively deleting directories. */
145 static Lisp_Object Qdelete_directory
;
147 static Lisp_Object Qsubstitute_env_in_file_name
;
152 Lisp_Object Qfile_error
, Qfile_notify_error
;
153 static Lisp_Object Qfile_already_exists
, Qfile_date_error
;
154 static Lisp_Object Qexcl
;
155 Lisp_Object Qfile_name_history
;
157 static Lisp_Object Qcar_less_than_car
;
159 static bool a_write (int, Lisp_Object
, ptrdiff_t, ptrdiff_t,
160 Lisp_Object
*, struct coding_system
*);
161 static bool e_write (int, Lisp_Object
, ptrdiff_t, ptrdiff_t,
162 struct coding_system
*);
165 /* Return true if FILENAME exists. */
168 check_existing (const char *filename
)
170 return faccessat (AT_FDCWD
, filename
, F_OK
, AT_EACCESS
) == 0;
173 /* Return true if file FILENAME exists and can be executed. */
176 check_executable (char *filename
)
178 return faccessat (AT_FDCWD
, filename
, X_OK
, AT_EACCESS
) == 0;
181 /* Return true if file FILENAME exists and can be accessed
182 according to AMODE, which should include W_OK.
183 On failure, return false and set errno. */
186 check_writable (const char *filename
, int amode
)
189 /* FIXME: an faccessat implementation should be added to the
190 DOS/Windows ports and this #ifdef branch should be removed. */
192 if (stat (filename
, &st
) < 0)
195 return (st
.st_mode
& S_IWRITE
|| S_ISDIR (st
.st_mode
));
196 #else /* not MSDOS */
197 bool res
= faccessat (AT_FDCWD
, filename
, amode
, AT_EACCESS
) == 0;
199 /* faccessat may have returned failure because Cygwin couldn't
200 determine the file's UID or GID; if so, we return success. */
203 int faccessat_errno
= errno
;
205 if (stat (filename
, &st
) < 0)
207 res
= (st
.st_uid
== -1 || st
.st_gid
== -1);
208 errno
= faccessat_errno
;
212 #endif /* not MSDOS */
215 /* Signal a file-access failure. STRING describes the failure,
216 NAME the file involved, and ERRORNO the errno value.
218 If NAME is neither null nor a pair, package it up as a singleton
219 list before reporting it; this saves report_file_errno's caller the
220 trouble of preserving errno before calling list1. */
223 report_file_errno (char const *string
, Lisp_Object name
, int errorno
)
225 Lisp_Object data
= CONSP (name
) || NILP (name
) ? name
: list1 (name
);
226 Lisp_Object errstring
;
229 synchronize_system_messages_locale ();
230 str
= strerror (errorno
);
231 errstring
= code_convert_string_norecord (build_unibyte_string (str
),
232 Vlocale_coding_system
, 0);
238 xsignal (Qfile_already_exists
, Fcons (errstring
, data
));
241 /* System error messages are capitalized. Downcase the initial
242 unless it is followed by a slash. (The slash case caters to
243 error messages that begin with "I/O" or, in German, "E/A".) */
244 if (STRING_MULTIBYTE (errstring
)
245 && ! EQ (Faref (errstring
, make_number (1)), make_number ('/')))
249 str
= SSDATA (errstring
);
250 c
= STRING_CHAR ((unsigned char *) str
);
251 Faset (errstring
, make_number (0), make_number (downcase (c
)));
254 xsignal (Qfile_error
,
255 Fcons (build_string (string
), Fcons (errstring
, data
)));
259 /* Signal a file-access failure that set errno. STRING describes the
260 failure, NAME the file involved. When invoking this function, take
261 care to not use arguments such as build_string ("foo") that involve
262 side effects that may set errno. */
265 report_file_error (char const *string
, Lisp_Object name
)
267 report_file_errno (string
, name
, errno
);
271 close_file_unwind (int fd
)
277 fclose_unwind (void *arg
)
283 /* Restore point, having saved it as a marker. */
286 restore_point_unwind (Lisp_Object location
)
288 Fgoto_char (location
);
289 unchain_marker (XMARKER (location
));
293 static Lisp_Object Qexpand_file_name
;
294 static Lisp_Object Qsubstitute_in_file_name
;
295 static Lisp_Object Qdirectory_file_name
;
296 static Lisp_Object Qfile_name_directory
;
297 static Lisp_Object Qfile_name_nondirectory
;
298 static Lisp_Object Qunhandled_file_name_directory
;
299 static Lisp_Object Qfile_name_as_directory
;
300 static Lisp_Object Qcopy_file
;
301 static Lisp_Object Qmake_directory_internal
;
302 static Lisp_Object Qmake_directory
;
303 static Lisp_Object Qdelete_directory_internal
;
304 Lisp_Object Qdelete_file
;
305 static Lisp_Object Qrename_file
;
306 static Lisp_Object Qadd_name_to_file
;
307 static Lisp_Object Qmake_symbolic_link
;
308 Lisp_Object Qfile_exists_p
;
309 static Lisp_Object Qfile_executable_p
;
310 static Lisp_Object Qfile_readable_p
;
311 static Lisp_Object Qfile_writable_p
;
312 static Lisp_Object Qfile_symlink_p
;
313 static Lisp_Object Qaccess_file
;
314 Lisp_Object Qfile_directory_p
;
315 static Lisp_Object Qfile_regular_p
;
316 static Lisp_Object Qfile_accessible_directory_p
;
317 static Lisp_Object Qfile_modes
;
318 static Lisp_Object Qset_file_modes
;
319 static Lisp_Object Qset_file_times
;
320 static Lisp_Object Qfile_selinux_context
;
321 static Lisp_Object Qset_file_selinux_context
;
322 static Lisp_Object Qfile_acl
;
323 static Lisp_Object Qset_file_acl
;
324 static Lisp_Object Qfile_newer_than_file_p
;
325 Lisp_Object Qinsert_file_contents
;
326 static Lisp_Object Qchoose_write_coding_system
;
327 Lisp_Object Qwrite_region
;
328 static Lisp_Object Qverify_visited_file_modtime
;
329 static Lisp_Object Qset_visited_file_modtime
;
331 DEFUN ("find-file-name-handler", Ffind_file_name_handler
,
332 Sfind_file_name_handler
, 2, 2, 0,
333 doc
: /* Return FILENAME's handler function for OPERATION, if it has one.
334 Otherwise, return nil.
335 A file name is handled if one of the regular expressions in
336 `file-name-handler-alist' matches it.
338 If OPERATION equals `inhibit-file-name-operation', then we ignore
339 any handlers that are members of `inhibit-file-name-handlers',
340 but we still do run any other handlers. This lets handlers
341 use the standard functions without calling themselves recursively. */)
342 (Lisp_Object filename
, Lisp_Object operation
)
344 /* This function must not munge the match data. */
345 Lisp_Object chain
, inhibited_handlers
, result
;
349 CHECK_STRING (filename
);
351 if (EQ (operation
, Vinhibit_file_name_operation
))
352 inhibited_handlers
= Vinhibit_file_name_handlers
;
354 inhibited_handlers
= Qnil
;
356 for (chain
= Vfile_name_handler_alist
; CONSP (chain
);
357 chain
= XCDR (chain
))
363 Lisp_Object string
= XCAR (elt
);
365 Lisp_Object handler
= XCDR (elt
);
366 Lisp_Object operations
= Qnil
;
368 if (SYMBOLP (handler
))
369 operations
= Fget (handler
, Qoperations
);
372 && (match_pos
= fast_string_match (string
, filename
)) > pos
373 && (NILP (operations
) || ! NILP (Fmemq (operation
, operations
))))
377 handler
= XCDR (elt
);
378 tem
= Fmemq (handler
, inhibited_handlers
);
392 DEFUN ("file-name-directory", Ffile_name_directory
, Sfile_name_directory
,
394 doc
: /* Return the directory component in file name FILENAME.
395 Return nil if FILENAME does not include a directory.
396 Otherwise return a directory name.
397 Given a Unix syntax file name, returns a string ending in slash. */)
398 (Lisp_Object filename
)
401 register const char *beg
;
406 register const char *p
;
409 CHECK_STRING (filename
);
411 /* If the file name has special constructs in it,
412 call the corresponding file handler. */
413 handler
= Ffind_file_name_handler (filename
, Qfile_name_directory
);
416 Lisp_Object handled_name
= call2 (handler
, Qfile_name_directory
,
418 return STRINGP (handled_name
) ? handled_name
: Qnil
;
422 beg
= xlispstrdupa (filename
);
424 beg
= SSDATA (filename
);
426 p
= beg
+ SBYTES (filename
);
428 while (p
!= beg
&& !IS_DIRECTORY_SEP (p
[-1])
430 /* only recognize drive specifier at the beginning */
432 /* handle the "/:d:foo" and "/:foo" cases correctly */
433 && ((p
== beg
+ 2 && !IS_DIRECTORY_SEP (*beg
))
434 || (p
== beg
+ 4 && IS_DIRECTORY_SEP (*beg
))))
441 /* Expansion of "c:" to drive and default directory. */
444 /* MAXPATHLEN+1 is guaranteed to be enough space for getdefdir. */
445 char *res
= alloca (MAXPATHLEN
+ 1);
448 if (p
== beg
+ 4 && IS_DIRECTORY_SEP (*beg
) && beg
[1] == ':')
450 memcpy (res
, beg
, 2);
455 if (getdefdir (c_toupper (*beg
) - 'A' + 1, r
))
457 size_t l
= strlen (res
);
459 if (l
> 3 || !IS_DIRECTORY_SEP (res
[l
- 1]))
462 p
= beg
+ strlen (beg
);
463 dostounix_filename (beg
, 0);
464 tem_fn
= make_specified_string (beg
, -1, p
- beg
,
465 STRING_MULTIBYTE (filename
));
468 tem_fn
= make_specified_string (beg
- 2, -1, p
- beg
+ 2,
469 STRING_MULTIBYTE (filename
));
471 else if (STRING_MULTIBYTE (filename
))
473 tem_fn
= make_specified_string (beg
, -1, p
- beg
, 1);
474 dostounix_filename (SSDATA (tem_fn
), 1);
476 if (!NILP (Vw32_downcase_file_names
))
477 tem_fn
= Fdowncase (tem_fn
);
482 dostounix_filename (beg
, 0);
483 tem_fn
= make_specified_string (beg
, -1, p
- beg
, 0);
487 return make_specified_string (beg
, -1, p
- beg
, STRING_MULTIBYTE (filename
));
491 DEFUN ("file-name-nondirectory", Ffile_name_nondirectory
,
492 Sfile_name_nondirectory
, 1, 1, 0,
493 doc
: /* Return file name FILENAME sans its directory.
494 For example, in a Unix-syntax file name,
495 this is everything after the last slash,
496 or the entire name if it contains no slash. */)
497 (Lisp_Object filename
)
499 register const char *beg
, *p
, *end
;
502 CHECK_STRING (filename
);
504 /* If the file name has special constructs in it,
505 call the corresponding file handler. */
506 handler
= Ffind_file_name_handler (filename
, Qfile_name_nondirectory
);
509 Lisp_Object handled_name
= call2 (handler
, Qfile_name_nondirectory
,
511 if (STRINGP (handled_name
))
513 error ("Invalid handler in `file-name-handler-alist'");
516 beg
= SSDATA (filename
);
517 end
= p
= beg
+ SBYTES (filename
);
519 while (p
!= beg
&& !IS_DIRECTORY_SEP (p
[-1])
521 /* only recognize drive specifier at beginning */
523 /* handle the "/:d:foo" case correctly */
524 && (p
== beg
+ 2 || (p
== beg
+ 4 && IS_DIRECTORY_SEP (*beg
))))
529 return make_specified_string (p
, -1, end
- p
, STRING_MULTIBYTE (filename
));
532 DEFUN ("unhandled-file-name-directory", Funhandled_file_name_directory
,
533 Sunhandled_file_name_directory
, 1, 1, 0,
534 doc
: /* Return a directly usable directory name somehow associated with FILENAME.
535 A `directly usable' directory name is one that may be used without the
536 intervention of any file handler.
537 If FILENAME is a directly usable file itself, return
538 \(file-name-directory FILENAME).
539 If FILENAME refers to a file which is not accessible from a local process,
540 then this should return nil.
541 The `call-process' and `start-process' functions use this function to
542 get a current directory to run processes in. */)
543 (Lisp_Object filename
)
547 /* If the file name has special constructs in it,
548 call the corresponding file handler. */
549 handler
= Ffind_file_name_handler (filename
, Qunhandled_file_name_directory
);
552 Lisp_Object handled_name
= call2 (handler
, Qunhandled_file_name_directory
,
554 return STRINGP (handled_name
) ? handled_name
: Qnil
;
557 return Ffile_name_directory (filename
);
560 /* Maximum number of bytes that DST will be longer than SRC
561 in file_name_as_directory. This occurs when SRCLEN == 0. */
562 enum { file_name_as_directory_slop
= 2 };
564 /* Convert from file name SRC of length SRCLEN to directory name in
565 DST. MULTIBYTE non-zero means the file name in SRC is a multibyte
566 string. On UNIX, just make sure there is a terminating /. Return
567 the length of DST in bytes. */
570 file_name_as_directory (char *dst
, const char *src
, ptrdiff_t srclen
,
581 memcpy (dst
, src
, srclen
);
582 if (!IS_DIRECTORY_SEP (dst
[srclen
- 1]))
583 dst
[srclen
++] = DIRECTORY_SEP
;
586 dostounix_filename (dst
, multibyte
);
591 DEFUN ("file-name-as-directory", Ffile_name_as_directory
,
592 Sfile_name_as_directory
, 1, 1, 0,
593 doc
: /* Return a string representing the file name FILE interpreted as a directory.
594 This operation exists because a directory is also a file, but its name as
595 a directory is different from its name as a file.
596 The result can be used as the value of `default-directory'
597 or passed as second argument to `expand-file-name'.
598 For a Unix-syntax file name, just appends a slash. */)
603 Lisp_Object handler
, val
;
610 /* If the file name has special constructs in it,
611 call the corresponding file handler. */
612 handler
= Ffind_file_name_handler (file
, Qfile_name_as_directory
);
615 Lisp_Object handled_name
= call2 (handler
, Qfile_name_as_directory
,
617 if (STRINGP (handled_name
))
619 error ("Invalid handler in `file-name-handler-alist'");
623 if (!NILP (Vw32_downcase_file_names
))
624 file
= Fdowncase (file
);
626 buf
= SAFE_ALLOCA (SBYTES (file
) + file_name_as_directory_slop
+ 1);
627 length
= file_name_as_directory (buf
, SSDATA (file
), SBYTES (file
),
628 STRING_MULTIBYTE (file
));
629 val
= make_specified_string (buf
, -1, length
, STRING_MULTIBYTE (file
));
634 /* Convert from directory name SRC of length SRCLEN to file name in
635 DST. MULTIBYTE non-zero means the file name in SRC is a multibyte
636 string. On UNIX, just make sure there isn't a terminating /.
637 Return the length of DST in bytes. */
640 directory_file_name (char *dst
, char *src
, ptrdiff_t srclen
, bool multibyte
)
642 /* Process as Unix format: just remove any final slash.
643 But leave "/" and "//" unchanged. */
646 && !IS_ANY_SEP (src
[srclen
- 2])
648 && IS_DIRECTORY_SEP (src
[srclen
- 1])
649 && ! (srclen
== 2 && IS_DIRECTORY_SEP (src
[0])))
652 memcpy (dst
, src
, srclen
);
655 dostounix_filename (dst
, multibyte
);
660 DEFUN ("directory-file-name", Fdirectory_file_name
, Sdirectory_file_name
,
662 doc
: /* Returns the file name of the directory named DIRECTORY.
663 This is the name of the file that holds the data for the directory DIRECTORY.
664 This operation exists because a directory is also a file, but its name as
665 a directory is different from its name as a file.
666 In Unix-syntax, this function just removes the final slash. */)
667 (Lisp_Object directory
)
671 Lisp_Object handler
, val
;
674 CHECK_STRING (directory
);
676 if (NILP (directory
))
679 /* If the file name has special constructs in it,
680 call the corresponding file handler. */
681 handler
= Ffind_file_name_handler (directory
, Qdirectory_file_name
);
684 Lisp_Object handled_name
= call2 (handler
, Qdirectory_file_name
,
686 if (STRINGP (handled_name
))
688 error ("Invalid handler in `file-name-handler-alist'");
692 if (!NILP (Vw32_downcase_file_names
))
693 directory
= Fdowncase (directory
);
695 buf
= SAFE_ALLOCA (SBYTES (directory
) + 1);
696 length
= directory_file_name (buf
, SSDATA (directory
), SBYTES (directory
),
697 STRING_MULTIBYTE (directory
));
698 val
= make_specified_string (buf
, -1, length
, STRING_MULTIBYTE (directory
));
703 static const char make_temp_name_tbl
[64] =
705 'A','B','C','D','E','F','G','H',
706 'I','J','K','L','M','N','O','P',
707 'Q','R','S','T','U','V','W','X',
708 'Y','Z','a','b','c','d','e','f',
709 'g','h','i','j','k','l','m','n',
710 'o','p','q','r','s','t','u','v',
711 'w','x','y','z','0','1','2','3',
712 '4','5','6','7','8','9','-','_'
715 static unsigned make_temp_name_count
, make_temp_name_count_initialized_p
;
717 /* Value is a temporary file name starting with PREFIX, a string.
719 The Emacs process number forms part of the result, so there is
720 no danger of generating a name being used by another process.
721 In addition, this function makes an attempt to choose a name
722 which has no existing file. To make this work, PREFIX should be
723 an absolute file name.
725 BASE64_P means add the pid as 3 characters in base64
726 encoding. In this case, 6 characters will be added to PREFIX to
727 form the file name. Otherwise, if Emacs is running on a system
728 with long file names, add the pid as a decimal number.
730 This function signals an error if no unique file name could be
734 make_temp_name (Lisp_Object prefix
, bool base64_p
)
736 Lisp_Object val
, encoded_prefix
;
740 char pidbuf
[INT_BUFSIZE_BOUND (printmax_t
)];
743 CHECK_STRING (prefix
);
745 /* VAL is created by adding 6 characters to PREFIX. The first
746 three are the PID of this process, in base 64, and the second
747 three are incremented if the file already exists. This ensures
748 262144 unique file names per PID per PREFIX. */
754 pidbuf
[0] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
755 pidbuf
[1] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
756 pidbuf
[2] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
761 #ifdef HAVE_LONG_FILE_NAMES
762 pidlen
= sprintf (pidbuf
, "%"pMd
, pid
);
764 pidbuf
[0] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
765 pidbuf
[1] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
766 pidbuf
[2] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
771 encoded_prefix
= ENCODE_FILE (prefix
);
772 len
= SBYTES (encoded_prefix
);
773 val
= make_uninit_string (len
+ 3 + pidlen
);
775 memcpy (data
, SSDATA (encoded_prefix
), len
);
778 memcpy (p
, pidbuf
, pidlen
);
781 /* Here we try to minimize useless stat'ing when this function is
782 invoked many times successively with the same PREFIX. We achieve
783 this by initializing count to a random value, and incrementing it
786 We don't want make-temp-name to be called while dumping,
787 because then make_temp_name_count_initialized_p would get set
788 and then make_temp_name_count would not be set when Emacs starts. */
790 if (!make_temp_name_count_initialized_p
)
792 make_temp_name_count
= time (NULL
);
793 make_temp_name_count_initialized_p
= 1;
798 unsigned num
= make_temp_name_count
;
800 p
[0] = make_temp_name_tbl
[num
& 63], num
>>= 6;
801 p
[1] = make_temp_name_tbl
[num
& 63], num
>>= 6;
802 p
[2] = make_temp_name_tbl
[num
& 63], num
>>= 6;
804 /* Poor man's congruential RN generator. Replace with
805 ++make_temp_name_count for debugging. */
806 make_temp_name_count
+= 25229;
807 make_temp_name_count
%= 225307;
809 if (!check_existing (data
))
811 /* We want to return only if errno is ENOENT. */
813 return DECODE_FILE (val
);
815 /* The error here is dubious, but there is little else we
816 can do. The alternatives are to return nil, which is
817 as bad as (and in many cases worse than) throwing the
818 error, or to ignore the error, which will likely result
819 in looping through 225307 stat's, which is not only
820 dog-slow, but also useless since eventually nil would
821 have to be returned anyway. */
822 report_file_error ("Cannot create temporary name for prefix",
830 DEFUN ("make-temp-name", Fmake_temp_name
, Smake_temp_name
, 1, 1, 0,
831 doc
: /* Generate temporary file name (string) starting with PREFIX (a string).
832 The Emacs process number forms part of the result,
833 so there is no danger of generating a name being used by another process.
835 In addition, this function makes an attempt to choose a name
836 which has no existing file. To make this work,
837 PREFIX should be an absolute file name.
839 There is a race condition between calling `make-temp-name' and creating the
840 file which opens all kinds of security holes. For that reason, you should
841 probably use `make-temp-file' instead, except in three circumstances:
843 * If you are creating the file in the user's home directory.
844 * If you are creating a directory rather than an ordinary file.
845 * If you are taking special precautions as `make-temp-file' does. */)
848 return make_temp_name (prefix
, 0);
853 DEFUN ("expand-file-name", Fexpand_file_name
, Sexpand_file_name
, 1, 2, 0,
854 doc
: /* Convert filename NAME to absolute, and canonicalize it.
855 Second arg DEFAULT-DIRECTORY is directory to start with if NAME is relative
856 \(does not start with slash or tilde); both the directory name and
857 a directory's file name are accepted. If DEFAULT-DIRECTORY is nil or
858 missing, the current buffer's value of `default-directory' is used.
859 NAME should be a string that is a valid file name for the underlying
861 File name components that are `.' are removed, and
862 so are file name components followed by `..', along with the `..' itself;
863 note that these simplifications are done without checking the resulting
864 file names in the file system.
865 Multiple consecutive slashes are collapsed into a single slash,
866 except at the beginning of the file name when they are significant (e.g.,
867 UNC file names on MS-Windows.)
868 An initial `~/' expands to your home directory.
869 An initial `~USER/' expands to USER's home directory.
870 See also the function `substitute-in-file-name'.
872 For technical reasons, this function can return correct but
873 non-intuitive results for the root directory; for instance,
874 \(expand-file-name ".." "/") returns "/..". For this reason, use
875 \(directory-file-name (file-name-directory dirname)) to traverse a
876 filesystem tree, not (expand-file-name ".." dirname). */)
877 (Lisp_Object name
, Lisp_Object default_directory
)
879 /* These point to SDATA and need to be careful with string-relocation
880 during GC (via DECODE_FILE). */
883 /* This should only point to alloca'd data. */
890 bool collapse_newdir
= 1;
894 Lisp_Object handler
, result
, handled_name
;
901 /* If the file name has special constructs in it,
902 call the corresponding file handler. */
903 handler
= Ffind_file_name_handler (name
, Qexpand_file_name
);
906 handled_name
= call3 (handler
, Qexpand_file_name
,
907 name
, default_directory
);
908 if (STRINGP (handled_name
))
910 error ("Invalid handler in `file-name-handler-alist'");
914 /* Use the buffer's default-directory if DEFAULT_DIRECTORY is omitted. */
915 if (NILP (default_directory
))
916 default_directory
= BVAR (current_buffer
, directory
);
917 if (! STRINGP (default_directory
))
920 /* "/" is not considered a root directory on DOS_NT, so using "/"
921 here causes an infinite recursion in, e.g., the following:
923 (let (default-directory)
924 (expand-file-name "a"))
926 To avoid this, we set default_directory to the root of the
928 default_directory
= build_string (emacs_root_dir ());
930 default_directory
= build_string ("/");
934 if (!NILP (default_directory
))
936 handler
= Ffind_file_name_handler (default_directory
, Qexpand_file_name
);
939 handled_name
= call3 (handler
, Qexpand_file_name
,
940 name
, default_directory
);
941 if (STRINGP (handled_name
))
943 error ("Invalid handler in `file-name-handler-alist'");
948 char *o
= SSDATA (default_directory
);
950 /* Make sure DEFAULT_DIRECTORY is properly expanded.
951 It would be better to do this down below where we actually use
952 default_directory. Unfortunately, calling Fexpand_file_name recursively
953 could invoke GC, and the strings might be relocated. This would
954 be annoying because we have pointers into strings lying around
955 that would need adjusting, and people would add new pointers to
956 the code and forget to adjust them, resulting in intermittent bugs.
957 Putting this call here avoids all that crud.
959 The EQ test avoids infinite recursion. */
960 if (! NILP (default_directory
) && !EQ (default_directory
, name
)
961 /* Save time in some common cases - as long as default_directory
962 is not relative, it can be canonicalized with name below (if it
963 is needed at all) without requiring it to be expanded now. */
965 /* Detect MSDOS file names with drive specifiers. */
966 && ! (IS_DRIVE (o
[0]) && IS_DEVICE_SEP (o
[1])
967 && IS_DIRECTORY_SEP (o
[2]))
969 /* Detect Windows file names in UNC format. */
970 && ! (IS_DIRECTORY_SEP (o
[0]) && IS_DIRECTORY_SEP (o
[1]))
972 #else /* not DOS_NT */
973 /* Detect Unix absolute file names (/... alone is not absolute on
975 && ! (IS_DIRECTORY_SEP (o
[0]))
976 #endif /* not DOS_NT */
982 default_directory
= Fexpand_file_name (default_directory
, Qnil
);
986 multibyte
= STRING_MULTIBYTE (name
);
987 if (multibyte
!= STRING_MULTIBYTE (default_directory
))
991 unsigned char *p
= SDATA (name
);
993 while (*p
&& ASCII_BYTE_P (*p
))
997 /* NAME is a pure ASCII string, and DEFAULT_DIRECTORY is
998 unibyte. Do not convert DEFAULT_DIRECTORY to
999 multibyte; instead, convert NAME to a unibyte string,
1000 so that the result of this function is also a unibyte
1001 string. This is needed during bootstrapping and
1002 dumping, when Emacs cannot decode file names, because
1003 the locale environment is not set up. */
1004 name
= make_unibyte_string (SSDATA (name
), SBYTES (name
));
1008 default_directory
= string_to_multibyte (default_directory
);
1012 name
= string_to_multibyte (name
);
1018 if (!NILP (Vw32_downcase_file_names
))
1019 default_directory
= Fdowncase (default_directory
);
1022 /* Make a local copy of nm[] to protect it from GC in DECODE_FILE below. */
1023 nm
= xlispstrdupa (name
);
1026 /* Note if special escape prefix is present, but remove for now. */
1027 if (nm
[0] == '/' && nm
[1] == ':')
1033 /* Find and remove drive specifier if present; this makes nm absolute
1034 even if the rest of the name appears to be relative. Only look for
1035 drive specifier at the beginning. */
1036 if (IS_DRIVE (nm
[0]) && IS_DEVICE_SEP (nm
[1]))
1038 drive
= (unsigned char) nm
[0];
1043 /* If we see "c://somedir", we want to strip the first slash after the
1044 colon when stripping the drive letter. Otherwise, this expands to
1046 if (drive
&& IS_DIRECTORY_SEP (nm
[0]) && IS_DIRECTORY_SEP (nm
[1]))
1049 /* Discard any previous drive specifier if nm is now in UNC format. */
1050 if (IS_DIRECTORY_SEP (nm
[0]) && IS_DIRECTORY_SEP (nm
[1]))
1054 #endif /* WINDOWSNT */
1057 /* If nm is absolute, look for `/./' or `/../' or `//''sequences; if
1058 none are found, we can probably return right away. We will avoid
1059 allocating a new string if name is already fully expanded. */
1061 IS_DIRECTORY_SEP (nm
[0])
1063 && drive
&& !is_escaped
1066 && (drive
|| IS_DIRECTORY_SEP (nm
[1])) && !is_escaped
1070 /* If it turns out that the filename we want to return is just a
1071 suffix of FILENAME, we don't need to go through and edit
1072 things; we just need to construct a new string using data
1073 starting at the middle of FILENAME. If we set LOSE, that
1074 means we've discovered that we can't do that cool trick. */
1080 /* Since we know the name is absolute, we can assume that each
1081 element starts with a "/". */
1083 /* "." and ".." are hairy. */
1084 if (IS_DIRECTORY_SEP (p
[0])
1086 && (IS_DIRECTORY_SEP (p
[2])
1088 || (p
[2] == '.' && (IS_DIRECTORY_SEP (p
[3])
1091 /* Replace multiple slashes with a single one, except
1092 leave leading "//" alone. */
1093 else if (IS_DIRECTORY_SEP (p
[0])
1094 && IS_DIRECTORY_SEP (p
[1])
1095 && (p
!= nm
|| IS_DIRECTORY_SEP (p
[2])))
1102 /* Make sure directories are all separated with /, but
1103 avoid allocation of a new string when not required. */
1104 dostounix_filename (nm
, multibyte
);
1106 if (IS_DIRECTORY_SEP (nm
[1]))
1108 if (strcmp (nm
, SSDATA (name
)) != 0)
1109 name
= make_specified_string (nm
, -1, strlen (nm
), multibyte
);
1113 /* Drive must be set, so this is okay. */
1114 if (strcmp (nm
- 2, SSDATA (name
)) != 0)
1118 name
= make_specified_string (nm
, -1, p
- nm
, multibyte
);
1119 temp
[0] = DRIVE_LETTER (drive
);
1120 name
= concat2 (build_string (temp
), name
);
1123 if (!NILP (Vw32_downcase_file_names
))
1124 name
= Fdowncase (name
);
1127 #else /* not DOS_NT */
1128 if (strcmp (nm
, SSDATA (name
)) == 0)
1130 return make_specified_string (nm
, -1, strlen (nm
), multibyte
);
1131 #endif /* not DOS_NT */
1135 /* At this point, nm might or might not be an absolute file name. We
1136 need to expand ~ or ~user if present, otherwise prefix nm with
1137 default_directory if nm is not absolute, and finally collapse /./
1138 and /foo/../ sequences.
1140 We set newdir to be the appropriate prefix if one is needed:
1141 - the relevant user directory if nm starts with ~ or ~user
1142 - the specified drive's working dir (DOS/NT only) if nm does not
1144 - the value of default_directory.
1146 Note that these prefixes are not guaranteed to be absolute (except
1147 for the working dir of a drive). Therefore, to ensure we always
1148 return an absolute name, if the final prefix is not absolute we
1149 append it to the current working directory. */
1153 if (nm
[0] == '~') /* prefix ~ */
1155 if (IS_DIRECTORY_SEP (nm
[1])
1156 || nm
[1] == 0) /* ~ by itself */
1160 if (!(newdir
= egetenv ("HOME")))
1163 /* `egetenv' may return a unibyte string, which will bite us since
1164 we expect the directory to be multibyte. */
1165 tem
= build_string (newdir
);
1166 if (multibyte
&& !STRING_MULTIBYTE (tem
))
1168 hdir
= DECODE_FILE (tem
);
1169 newdir
= SSDATA (hdir
);
1172 collapse_newdir
= 0;
1175 else /* ~user/filename */
1178 for (p
= nm
; *p
&& !IS_DIRECTORY_SEP (*p
); p
++)
1180 o
= SAFE_ALLOCA (p
- nm
+ 1);
1181 memcpy (o
, nm
, p
- nm
);
1185 pw
= getpwnam (o
+ 1);
1191 newdir
= pw
->pw_dir
;
1192 /* `getpwnam' may return a unibyte string, which will
1193 bite us since we expect the directory to be
1195 tem
= build_string (newdir
);
1196 if (multibyte
&& !STRING_MULTIBYTE (tem
))
1198 hdir
= DECODE_FILE (tem
);
1199 newdir
= SSDATA (hdir
);
1203 collapse_newdir
= 0;
1207 /* If we don't find a user of that name, leave the name
1208 unchanged; don't move nm forward to p. */
1213 /* On DOS and Windows, nm is absolute if a drive name was specified;
1214 use the drive's current directory as the prefix if needed. */
1215 if (!newdir
&& drive
)
1217 /* Get default directory if needed to make nm absolute. */
1219 if (!IS_DIRECTORY_SEP (nm
[0]))
1221 adir
= alloca (MAXPATHLEN
+ 1);
1222 if (!getdefdir (c_toupper (drive
) - 'A' + 1, adir
))
1226 Lisp_Object tem
= build_string (adir
);
1228 tem
= DECODE_FILE (tem
);
1229 memcpy (adir
, SSDATA (tem
), SBYTES (tem
) + 1);
1234 /* Either nm starts with /, or drive isn't mounted. */
1236 adir
[0] = DRIVE_LETTER (drive
);
1245 /* Finally, if no prefix has been specified and nm is not absolute,
1246 then it must be expanded relative to default_directory. */
1250 /* /... alone is not absolute on DOS and Windows. */
1251 && !IS_DIRECTORY_SEP (nm
[0])
1254 && !(IS_DIRECTORY_SEP (nm
[0]) && IS_DIRECTORY_SEP (nm
[1]))
1258 newdir
= SSDATA (default_directory
);
1260 /* Note if special escape prefix is present, but remove for now. */
1261 if (newdir
[0] == '/' && newdir
[1] == ':')
1272 /* First ensure newdir is an absolute name. */
1274 /* Detect MSDOS file names with drive specifiers. */
1275 ! (IS_DRIVE (newdir
[0])
1276 && IS_DEVICE_SEP (newdir
[1]) && IS_DIRECTORY_SEP (newdir
[2]))
1278 /* Detect Windows file names in UNC format. */
1279 && ! (IS_DIRECTORY_SEP (newdir
[0]) && IS_DIRECTORY_SEP (newdir
[1]))
1283 /* Effectively, let newdir be (expand-file-name newdir cwd).
1284 Because of the admonition against calling expand-file-name
1285 when we have pointers into lisp strings, we accomplish this
1286 indirectly by prepending newdir to nm if necessary, and using
1287 cwd (or the wd of newdir's drive) as the new newdir. */
1290 if (IS_DRIVE (newdir
[0]) && IS_DEVICE_SEP (newdir
[1]))
1292 drive
= (unsigned char) newdir
[0];
1295 if (!IS_DIRECTORY_SEP (nm
[0]))
1297 ptrdiff_t newlen
= strlen (newdir
);
1298 char *tmp
= alloca (newlen
+ file_name_as_directory_slop
1300 file_name_as_directory (tmp
, newdir
, newlen
, multibyte
);
1304 adir
= alloca (MAXPATHLEN
+ 1);
1307 if (!getdefdir (c_toupper (drive
) - 'A' + 1, adir
))
1311 getcwd (adir
, MAXPATHLEN
+ 1);
1314 Lisp_Object tem
= build_string (adir
);
1316 tem
= DECODE_FILE (tem
);
1317 memcpy (adir
, SSDATA (tem
), SBYTES (tem
) + 1);
1322 /* Strip off drive name from prefix, if present. */
1323 if (IS_DRIVE (newdir
[0]) && IS_DEVICE_SEP (newdir
[1]))
1329 /* Keep only a prefix from newdir if nm starts with slash
1330 (//server/share for UNC, nothing otherwise). */
1331 if (IS_DIRECTORY_SEP (nm
[0]) && collapse_newdir
)
1334 if (IS_DIRECTORY_SEP (newdir
[0]) && IS_DIRECTORY_SEP (newdir
[1]))
1336 char *adir
= strcpy (alloca (strlen (newdir
) + 1), newdir
);
1338 while (*p
&& !IS_DIRECTORY_SEP (*p
)) p
++;
1340 while (*p
&& !IS_DIRECTORY_SEP (*p
)) p
++;
1353 /* Ignore any slash at the end of newdir, unless newdir is
1354 just "/" or "//". */
1355 length
= strlen (newdir
);
1356 while (length
> 1 && IS_DIRECTORY_SEP (newdir
[length
- 1])
1357 && ! (length
== 2 && IS_DIRECTORY_SEP (newdir
[0])))
1363 /* Now concatenate the directory and name to new space in the stack frame. */
1364 tlen
= length
+ file_name_as_directory_slop
+ strlen (nm
) + 1;
1366 /* Reserve space for drive specifier and escape prefix, since either
1367 or both may need to be inserted. (The Microsoft x86 compiler
1368 produces incorrect code if the following two lines are combined.) */
1369 target
= alloca (tlen
+ 4);
1371 #else /* not DOS_NT */
1372 target
= SAFE_ALLOCA (tlen
);
1373 #endif /* not DOS_NT */
1378 if (nm
[0] == 0 || IS_DIRECTORY_SEP (nm
[0]))
1381 /* If newdir is effectively "C:/", then the drive letter will have
1382 been stripped and newdir will be "/". Concatenating with an
1383 absolute directory in nm produces "//", which will then be
1384 incorrectly treated as a network share. Ignore newdir in
1385 this case (keeping the drive letter). */
1386 if (!(drive
&& nm
[0] && IS_DIRECTORY_SEP (newdir
[0])
1387 && newdir
[1] == '\0'))
1390 memcpy (target
, newdir
, length
);
1395 file_name_as_directory (target
, newdir
, length
, multibyte
);
1398 strcat (target
, nm
);
1400 /* Now canonicalize by removing `//', `/.' and `/foo/..' if they
1408 if (!IS_DIRECTORY_SEP (*p
))
1412 else if (p
[1] == '.'
1413 && (IS_DIRECTORY_SEP (p
[2])
1416 /* If "/." is the entire filename, keep the "/". Otherwise,
1417 just delete the whole "/.". */
1418 if (o
== target
&& p
[2] == '\0')
1422 else if (p
[1] == '.' && p
[2] == '.'
1423 /* `/../' is the "superroot" on certain file systems.
1424 Turned off on DOS_NT systems because they have no
1425 "superroot" and because this causes us to produce
1426 file names like "d:/../foo" which fail file-related
1427 functions of the underlying OS. (To reproduce, try a
1428 long series of "../../" in default_directory, longer
1429 than the number of levels from the root.) */
1433 && (IS_DIRECTORY_SEP (p
[3]) || p
[3] == 0))
1438 while (o
!= target
&& (--o
, !IS_DIRECTORY_SEP (*o
)))
1441 /* Don't go below server level in UNC filenames. */
1442 if (o
== target
+ 1 && IS_DIRECTORY_SEP (*o
)
1443 && IS_DIRECTORY_SEP (*target
))
1447 /* Keep initial / only if this is the whole name. */
1448 if (o
== target
&& IS_ANY_SEP (*o
) && p
[3] == 0)
1452 else if (IS_DIRECTORY_SEP (p
[1])
1453 && (p
!= target
|| IS_DIRECTORY_SEP (p
[2])))
1454 /* Collapse multiple "/", except leave leading "//" alone. */
1463 /* At last, set drive name. */
1465 /* Except for network file name. */
1466 if (!(IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1])))
1467 #endif /* WINDOWSNT */
1469 if (!drive
) emacs_abort ();
1471 target
[0] = DRIVE_LETTER (drive
);
1474 /* Reinsert the escape prefix if required. */
1481 result
= make_specified_string (target
, -1, o
- target
, multibyte
);
1482 dostounix_filename (SSDATA (result
), multibyte
);
1484 if (!NILP (Vw32_downcase_file_names
))
1485 result
= Fdowncase (result
);
1488 result
= make_specified_string (target
, -1, o
- target
, multibyte
);
1489 #endif /* !DOS_NT */
1492 /* Again look to see if the file name has special constructs in it
1493 and perhaps call the corresponding file handler. This is needed
1494 for filenames such as "/foo/../user@host:/bar/../baz". Expanding
1495 the ".." component gives us "/user@host:/bar/../baz" which needs
1496 to be expanded again. */
1497 handler
= Ffind_file_name_handler (result
, Qexpand_file_name
);
1498 if (!NILP (handler
))
1500 handled_name
= call3 (handler
, Qexpand_file_name
,
1501 result
, default_directory
);
1502 if (! STRINGP (handled_name
))
1503 error ("Invalid handler in `file-name-handler-alist'");
1504 result
= handled_name
;
1512 /* PLEASE DO NOT DELETE THIS COMMENTED-OUT VERSION!
1513 This is the old version of expand-file-name, before it was thoroughly
1514 rewritten for Emacs 10.31. We leave this version here commented-out,
1515 because the code is very complex and likely to have subtle bugs. If
1516 bugs _are_ found, it might be of interest to look at the old code and
1517 see what did it do in the relevant situation.
1519 Don't remove this code: it's true that it will be accessible
1520 from the repository, but a few years from deletion, people will
1521 forget it is there. */
1523 /* Changed this DEFUN to a DEAFUN, so as not to confuse `make-docfile'. */
1524 DEAFUN ("expand-file-name", Fexpand_file_name
, Sexpand_file_name
, 1, 2, 0,
1525 "Convert FILENAME to absolute, and canonicalize it.\n\
1526 Second arg DEFAULT is directory to start with if FILENAME is relative\n\
1527 \(does not start with slash); if DEFAULT is nil or missing,\n\
1528 the current buffer's value of default-directory is used.\n\
1529 Filenames containing `.' or `..' as components are simplified;\n\
1530 initial `~/' expands to your home directory.\n\
1531 See also the function `substitute-in-file-name'.")
1533 Lisp_Object name
, defalt
;
1537 register unsigned char *newdir
, *p
, *o
;
1539 unsigned char *target
;
1542 CHECK_STRING (name
);
1545 /* If nm is absolute, flush ...// and detect /./ and /../.
1546 If no /./ or /../ we can return right away. */
1553 if (p
[0] == '/' && p
[1] == '/')
1555 if (p
[0] == '/' && p
[1] == '~')
1556 nm
= p
+ 1, lose
= 1;
1557 if (p
[0] == '/' && p
[1] == '.'
1558 && (p
[2] == '/' || p
[2] == 0
1559 || (p
[2] == '.' && (p
[3] == '/' || p
[3] == 0))))
1565 if (nm
== SDATA (name
))
1567 return build_string (nm
);
1571 /* Now determine directory to start with and put it in NEWDIR. */
1575 if (nm
[0] == '~') /* prefix ~ */
1576 if (nm
[1] == '/' || nm
[1] == 0)/* ~/filename */
1578 if (!(newdir
= (unsigned char *) egetenv ("HOME")))
1579 newdir
= (unsigned char *) "";
1582 else /* ~user/filename */
1584 /* Get past ~ to user. */
1585 unsigned char *user
= nm
+ 1;
1586 /* Find end of name. */
1587 unsigned char *ptr
= (unsigned char *) strchr (user
, '/');
1588 ptrdiff_t len
= ptr
? ptr
- user
: strlen (user
);
1589 /* Copy the user name into temp storage. */
1590 o
= alloca (len
+ 1);
1591 memcpy (o
, user
, len
);
1594 /* Look up the user name. */
1596 pw
= (struct passwd
*) getpwnam (o
+ 1);
1599 error ("\"%s\" isn't a registered user", o
+ 1);
1601 newdir
= (unsigned char *) pw
->pw_dir
;
1603 /* Discard the user name from NM. */
1607 if (nm
[0] != '/' && !newdir
)
1610 defalt
= current_buffer
->directory
;
1611 CHECK_STRING (defalt
);
1612 newdir
= SDATA (defalt
);
1615 /* Now concatenate the directory and name to new space in the stack frame. */
1617 tlen
= (newdir
? strlen (newdir
) + 1 : 0) + strlen (nm
) + 1;
1618 target
= alloca (tlen
);
1623 if (nm
[0] == 0 || nm
[0] == '/')
1624 strcpy (target
, newdir
);
1626 file_name_as_directory (target
, newdir
);
1629 strcat (target
, nm
);
1631 /* Now canonicalize by removing /. and /foo/.. if they appear. */
1642 else if (!strncmp (p
, "//", 2)
1648 else if (p
[0] == '/' && p
[1] == '.'
1649 && (p
[2] == '/' || p
[2] == 0))
1651 else if (!strncmp (p
, "/..", 3)
1652 /* `/../' is the "superroot" on certain file systems. */
1654 && (p
[3] == '/' || p
[3] == 0))
1656 while (o
!= target
&& *--o
!= '/')
1658 if (o
== target
&& *o
== '/')
1668 return make_string (target
, o
- target
);
1672 /* If /~ or // appears, discard everything through first slash. */
1674 file_name_absolute_p (const char *filename
)
1677 (IS_DIRECTORY_SEP (*filename
) || *filename
== '~'
1679 || (IS_DRIVE (*filename
) && IS_DEVICE_SEP (filename
[1])
1680 && IS_DIRECTORY_SEP (filename
[2]))
1686 search_embedded_absfilename (char *nm
, char *endp
)
1690 for (p
= nm
+ 1; p
< endp
; p
++)
1692 if (IS_DIRECTORY_SEP (p
[-1])
1693 && file_name_absolute_p (p
)
1694 #if defined (WINDOWSNT) || defined (CYGWIN)
1695 /* // at start of file name is meaningful in Apollo,
1696 WindowsNT and Cygwin systems. */
1697 && !(IS_DIRECTORY_SEP (p
[0]) && p
- 1 == nm
)
1698 #endif /* not (WINDOWSNT || CYGWIN) */
1701 for (s
= p
; *s
&& !IS_DIRECTORY_SEP (*s
); s
++);
1702 if (p
[0] == '~' && s
> p
+ 1) /* We've got "/~something/". */
1704 char *o
= alloca (s
- p
+ 1);
1706 memcpy (o
, p
, s
- p
);
1709 /* If we have ~user and `user' exists, discard
1710 everything up to ~. But if `user' does not exist, leave
1711 ~user alone, it might be a literal file name. */
1713 pw
= getpwnam (o
+ 1);
1725 DEFUN ("substitute-in-file-name", Fsubstitute_in_file_name
,
1726 Ssubstitute_in_file_name
, 1, 1, 0,
1727 doc
: /* Substitute environment variables referred to in FILENAME.
1728 `$FOO' where FOO is an environment variable name means to substitute
1729 the value of that variable. The variable name should be terminated
1730 with a character not a letter, digit or underscore; otherwise, enclose
1731 the entire variable name in braces.
1733 If `/~' appears, all of FILENAME through that `/' is discarded.
1734 If `//' appears, everything up to and including the first of
1735 those `/' is discarded. */)
1736 (Lisp_Object filename
)
1738 char *nm
, *p
, *x
, *endp
;
1739 bool substituted
= false;
1742 Lisp_Object handler
;
1744 CHECK_STRING (filename
);
1746 multibyte
= STRING_MULTIBYTE (filename
);
1748 /* If the file name has special constructs in it,
1749 call the corresponding file handler. */
1750 handler
= Ffind_file_name_handler (filename
, Qsubstitute_in_file_name
);
1751 if (!NILP (handler
))
1753 Lisp_Object handled_name
= call2 (handler
, Qsubstitute_in_file_name
,
1755 if (STRINGP (handled_name
))
1756 return handled_name
;
1757 error ("Invalid handler in `file-name-handler-alist'");
1760 /* Always work on a copy of the string, in case GC happens during
1761 decode of environment variables, causing the original Lisp_String
1762 data to be relocated. */
1763 nm
= xlispstrdupa (filename
);
1766 dostounix_filename (nm
, multibyte
);
1767 substituted
= (memcmp (nm
, SDATA (filename
), SBYTES (filename
)) != 0);
1769 endp
= nm
+ SBYTES (filename
);
1771 /* If /~ or // appears, discard everything through first slash. */
1772 p
= search_embedded_absfilename (nm
, endp
);
1774 /* Start over with the new string, so we check the file-name-handler
1775 again. Important with filenames like "/home/foo//:/hello///there"
1776 which would substitute to "/:/hello///there" rather than "/there". */
1777 return Fsubstitute_in_file_name
1778 (make_specified_string (p
, -1, endp
- p
, multibyte
));
1780 /* See if any variables are substituted into the string. */
1782 if (!NILP (Ffboundp (Qsubstitute_env_in_file_name
)))
1785 = (!substituted
? filename
1786 : make_specified_string (nm
, -1, endp
- nm
, multibyte
));
1787 Lisp_Object tmp
= call1 (Qsubstitute_env_in_file_name
, name
);
1789 if (!EQ (tmp
, name
))
1797 if (!NILP (Vw32_downcase_file_names
))
1798 filename
= Fdowncase (filename
);
1803 xnm
= SSDATA (filename
);
1804 x
= xnm
+ SBYTES (filename
);
1806 /* If /~ or // appears, discard everything through first slash. */
1807 while ((p
= search_embedded_absfilename (xnm
, x
)) != NULL
)
1808 /* This time we do not start over because we've already expanded envvars
1809 and replaced $$ with $. Maybe we should start over as well, but we'd
1810 need to quote some $ to $$ first. */
1814 if (!NILP (Vw32_downcase_file_names
))
1816 Lisp_Object xname
= make_specified_string (xnm
, -1, x
- xnm
, multibyte
);
1818 xname
= Fdowncase (xname
);
1823 return (xnm
== SSDATA (filename
)
1825 : make_specified_string (xnm
, -1, x
- xnm
, multibyte
));
1828 /* A slightly faster and more convenient way to get
1829 (directory-file-name (expand-file-name FOO)). */
1832 expand_and_dir_to_file (Lisp_Object filename
, Lisp_Object defdir
)
1834 register Lisp_Object absname
;
1836 absname
= Fexpand_file_name (filename
, defdir
);
1838 /* Remove final slash, if any (unless this is the root dir).
1839 stat behaves differently depending! */
1840 if (SCHARS (absname
) > 1
1841 && IS_DIRECTORY_SEP (SREF (absname
, SBYTES (absname
) - 1))
1842 && !IS_DEVICE_SEP (SREF (absname
, SBYTES (absname
) - 2)))
1843 /* We cannot take shortcuts; they might be wrong for magic file names. */
1844 absname
= Fdirectory_file_name (absname
);
1848 /* Signal an error if the file ABSNAME already exists.
1849 If INTERACTIVE, ask the user whether to proceed,
1850 and bypass the error if the user says to go ahead.
1851 QUERYSTRING is a name for the action that is being considered
1854 *STATPTR is used to store the stat information if the file exists.
1855 If the file does not exist, STATPTR->st_mode is set to 0.
1856 If STATPTR is null, we don't store into it.
1858 If QUICK, ask for y or n, not yes or no. */
1861 barf_or_query_if_file_exists (Lisp_Object absname
, const char *querystring
,
1862 bool interactive
, struct stat
*statptr
,
1865 Lisp_Object tem
, encoded_filename
;
1866 struct stat statbuf
;
1867 struct gcpro gcpro1
;
1869 encoded_filename
= ENCODE_FILE (absname
);
1871 /* `stat' is a good way to tell whether the file exists,
1872 regardless of what access permissions it has. */
1873 if (lstat (SSDATA (encoded_filename
), &statbuf
) >= 0)
1875 if (S_ISDIR (statbuf
.st_mode
))
1876 xsignal2 (Qfile_error
,
1877 build_string ("File is a directory"), absname
);
1880 xsignal2 (Qfile_already_exists
,
1881 build_string ("File already exists"), absname
);
1883 tem
= format2 ("File %s already exists; %s anyway? ",
1884 absname
, build_string (querystring
));
1886 tem
= call1 (intern ("y-or-n-p"), tem
);
1888 tem
= do_yes_or_no_p (tem
);
1891 xsignal2 (Qfile_already_exists
,
1892 build_string ("File already exists"), absname
);
1899 statptr
->st_mode
= 0;
1904 DEFUN ("copy-file", Fcopy_file
, Scopy_file
, 2, 6,
1905 "fCopy file: \nGCopy %s to file: \np\nP",
1906 doc
: /* Copy FILE to NEWNAME. Both args must be strings.
1907 If NEWNAME names a directory, copy FILE there.
1909 This function always sets the file modes of the output file to match
1912 The optional third argument OK-IF-ALREADY-EXISTS specifies what to do
1913 if file NEWNAME already exists. If OK-IF-ALREADY-EXISTS is nil, we
1914 signal a `file-already-exists' error without overwriting. If
1915 OK-IF-ALREADY-EXISTS is a number, we request confirmation from the user
1916 about overwriting; this is what happens in interactive use with M-x.
1917 Any other value for OK-IF-ALREADY-EXISTS means to overwrite the
1920 Fourth arg KEEP-TIME non-nil means give the output file the same
1921 last-modified time as the old one. (This works on only some systems.)
1923 A prefix arg makes KEEP-TIME non-nil.
1925 If PRESERVE-UID-GID is non-nil, we try to transfer the
1926 uid and gid of FILE to NEWNAME.
1928 If PRESERVE-EXTENDED-ATTRIBUTES is non-nil, we try to copy additional
1929 attributes of FILE to NEWNAME, such as its SELinux context and ACL
1930 entries (depending on how Emacs was built). */)
1931 (Lisp_Object file
, Lisp_Object newname
, Lisp_Object ok_if_already_exists
, Lisp_Object keep_time
, Lisp_Object preserve_uid_gid
, Lisp_Object preserve_extended_attributes
)
1935 char buf
[16 * 1024];
1936 struct stat st
, out_st
;
1937 Lisp_Object handler
;
1938 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1939 ptrdiff_t count
= SPECPDL_INDEX ();
1940 Lisp_Object encoded_file
, encoded_newname
;
1942 security_context_t con
;
1949 encoded_file
= encoded_newname
= Qnil
;
1950 GCPRO4 (file
, newname
, encoded_file
, encoded_newname
);
1951 CHECK_STRING (file
);
1952 CHECK_STRING (newname
);
1954 if (!NILP (Ffile_directory_p (newname
)))
1955 newname
= Fexpand_file_name (Ffile_name_nondirectory (file
), newname
);
1957 newname
= Fexpand_file_name (newname
, Qnil
);
1959 file
= Fexpand_file_name (file
, Qnil
);
1961 /* If the input file name has special constructs in it,
1962 call the corresponding file handler. */
1963 handler
= Ffind_file_name_handler (file
, Qcopy_file
);
1964 /* Likewise for output file name. */
1966 handler
= Ffind_file_name_handler (newname
, Qcopy_file
);
1967 if (!NILP (handler
))
1968 RETURN_UNGCPRO (call7 (handler
, Qcopy_file
, file
, newname
,
1969 ok_if_already_exists
, keep_time
, preserve_uid_gid
,
1970 preserve_extended_attributes
));
1972 encoded_file
= ENCODE_FILE (file
);
1973 encoded_newname
= ENCODE_FILE (newname
);
1975 if (NILP (ok_if_already_exists
)
1976 || INTEGERP (ok_if_already_exists
))
1977 barf_or_query_if_file_exists (newname
, "copy to it",
1978 INTEGERP (ok_if_already_exists
), &out_st
, 0);
1979 else if (stat (SSDATA (encoded_newname
), &out_st
) < 0)
1983 if (!NILP (preserve_extended_attributes
))
1985 acl
= acl_get_file (SDATA (encoded_file
), ACL_TYPE_ACCESS
);
1986 if (acl
== NULL
&& acl_errno_valid (errno
))
1987 report_file_error ("Getting ACL", file
);
1989 if (!CopyFile (SDATA (encoded_file
),
1990 SDATA (encoded_newname
),
1993 /* CopyFile doesn't set errno when it fails. By far the most
1994 "popular" reason is that the target is read-only. */
1995 report_file_errno ("Copying file", list2 (file
, newname
),
1996 GetLastError () == 5 ? EACCES
: EPERM
);
1998 /* CopyFile retains the timestamp by default. */
1999 else if (NILP (keep_time
))
2001 struct timespec now
;
2005 filename
= SDATA (encoded_newname
);
2007 /* Ensure file is writable while its modified time is set. */
2008 attributes
= GetFileAttributes (filename
);
2009 SetFileAttributes (filename
, attributes
& ~FILE_ATTRIBUTE_READONLY
);
2010 now
= current_timespec ();
2011 if (set_file_times (-1, filename
, now
, now
))
2013 /* Restore original attributes. */
2014 SetFileAttributes (filename
, attributes
);
2015 xsignal2 (Qfile_date_error
,
2016 build_string ("Cannot set file date"), newname
);
2018 /* Restore original attributes. */
2019 SetFileAttributes (filename
, attributes
);
2024 acl_set_file (SDATA (encoded_newname
), ACL_TYPE_ACCESS
, acl
) != 0;
2025 if (fail
&& acl_errno_valid (errno
))
2026 report_file_error ("Setting ACL", newname
);
2030 #else /* not WINDOWSNT */
2032 ifd
= emacs_open (SSDATA (encoded_file
), O_RDONLY
, 0);
2036 report_file_error ("Opening input file", file
);
2038 record_unwind_protect_int (close_file_unwind
, ifd
);
2040 if (fstat (ifd
, &st
) != 0)
2041 report_file_error ("Input file status", file
);
2043 if (!NILP (preserve_extended_attributes
))
2046 if (is_selinux_enabled ())
2048 conlength
= fgetfilecon (ifd
, &con
);
2049 if (conlength
== -1)
2050 report_file_error ("Doing fgetfilecon", file
);
2055 if (out_st
.st_mode
!= 0
2056 && st
.st_dev
== out_st
.st_dev
&& st
.st_ino
== out_st
.st_ino
)
2057 report_file_errno ("Input and output files are the same",
2058 list2 (file
, newname
), 0);
2060 /* We can copy only regular files. */
2061 if (!S_ISREG (st
.st_mode
))
2062 report_file_errno ("Non-regular file", file
,
2063 S_ISDIR (st
.st_mode
) ? EISDIR
: EINVAL
);
2067 int new_mask
= st
.st_mode
& (!NILP (preserve_uid_gid
) ? 0600 : 0666);
2069 int new_mask
= S_IREAD
| S_IWRITE
;
2071 ofd
= emacs_open (SSDATA (encoded_newname
),
2072 (O_WRONLY
| O_TRUNC
| O_CREAT
2073 | (NILP (ok_if_already_exists
) ? O_EXCL
: 0)),
2077 report_file_error ("Opening output file", newname
);
2079 record_unwind_protect_int (close_file_unwind
, ofd
);
2083 while ((n
= emacs_read (ifd
, buf
, sizeof buf
)) > 0)
2084 if (emacs_write_sig (ofd
, buf
, n
) != n
)
2085 report_file_error ("Write error", newname
);
2089 /* Preserve the original file permissions, and if requested, also its
2092 mode_t mode_mask
= 07777;
2093 if (!NILP (preserve_uid_gid
))
2095 /* Attempt to change owner and group. If that doesn't work
2096 attempt to change just the group, as that is sometimes allowed.
2097 Adjust the mode mask to eliminate setuid or setgid bits
2098 that are inappropriate if the owner and group are wrong. */
2099 if (fchown (ofd
, st
.st_uid
, st
.st_gid
) != 0)
2101 mode_mask
&= ~06000;
2102 if (fchown (ofd
, -1, st
.st_gid
) == 0)
2107 switch (!NILP (preserve_extended_attributes
)
2108 ? qcopy_acl (SSDATA (encoded_file
), ifd
,
2109 SSDATA (encoded_newname
), ofd
,
2110 st
.st_mode
& mode_mask
)
2111 : fchmod (ofd
, st
.st_mode
& mode_mask
))
2113 case -2: report_file_error ("Copying permissions from", file
);
2114 case -1: report_file_error ("Copying permissions to", newname
);
2117 #endif /* not MSDOS */
2122 /* Set the modified context back to the file. */
2123 bool fail
= fsetfilecon (ofd
, con
) != 0;
2124 /* See http://debbugs.gnu.org/11245 for ENOTSUP. */
2125 if (fail
&& errno
!= ENOTSUP
)
2126 report_file_error ("Doing fsetfilecon", newname
);
2132 if (!NILP (keep_time
))
2134 struct timespec atime
= get_stat_atime (&st
);
2135 struct timespec mtime
= get_stat_mtime (&st
);
2136 if (set_file_times (ofd
, SSDATA (encoded_newname
), atime
, mtime
))
2137 xsignal2 (Qfile_date_error
,
2138 build_string ("Cannot set file date"), newname
);
2141 if (emacs_close (ofd
) < 0)
2142 report_file_error ("Write error", newname
);
2147 /* In DJGPP v2.0 and later, fstat usually returns true file mode bits,
2148 and if it can't, it tells so. Otherwise, under MSDOS we usually
2149 get only the READ bit, which will make the copied file read-only,
2150 so it's better not to chmod at all. */
2151 if ((_djstat_flags
& _STFAIL_WRITEBIT
) == 0)
2152 chmod (SDATA (encoded_newname
), st
.st_mode
& 07777);
2154 #endif /* not WINDOWSNT */
2156 /* Discard the unwind protects. */
2157 specpdl_ptr
= specpdl
+ count
;
2163 DEFUN ("make-directory-internal", Fmake_directory_internal
,
2164 Smake_directory_internal
, 1, 1, 0,
2165 doc
: /* Create a new directory named DIRECTORY. */)
2166 (Lisp_Object directory
)
2169 Lisp_Object handler
;
2170 Lisp_Object encoded_dir
;
2172 CHECK_STRING (directory
);
2173 directory
= Fexpand_file_name (directory
, Qnil
);
2175 handler
= Ffind_file_name_handler (directory
, Qmake_directory_internal
);
2176 if (!NILP (handler
))
2177 return call2 (handler
, Qmake_directory_internal
, directory
);
2179 encoded_dir
= ENCODE_FILE (directory
);
2181 dir
= SSDATA (encoded_dir
);
2184 if (mkdir (dir
) != 0)
2186 if (mkdir (dir
, 0777 & ~auto_saving_dir_umask
) != 0)
2188 report_file_error ("Creating directory", directory
);
2193 DEFUN ("delete-directory-internal", Fdelete_directory_internal
,
2194 Sdelete_directory_internal
, 1, 1, 0,
2195 doc
: /* Delete the directory named DIRECTORY. Does not follow symlinks. */)
2196 (Lisp_Object directory
)
2199 Lisp_Object encoded_dir
;
2201 CHECK_STRING (directory
);
2202 directory
= Fdirectory_file_name (Fexpand_file_name (directory
, Qnil
));
2203 encoded_dir
= ENCODE_FILE (directory
);
2204 dir
= SSDATA (encoded_dir
);
2206 if (rmdir (dir
) != 0)
2207 report_file_error ("Removing directory", directory
);
2212 DEFUN ("delete-file", Fdelete_file
, Sdelete_file
, 1, 2,
2213 "(list (read-file-name \
2214 (if (and delete-by-moving-to-trash (null current-prefix-arg)) \
2215 \"Move file to trash: \" \"Delete file: \") \
2216 nil default-directory (confirm-nonexistent-file-or-buffer)) \
2217 (null current-prefix-arg))",
2218 doc
: /* Delete file named FILENAME. If it is a symlink, remove the symlink.
2219 If file has multiple names, it continues to exist with the other names.
2220 TRASH non-nil means to trash the file instead of deleting, provided
2221 `delete-by-moving-to-trash' is non-nil.
2223 When called interactively, TRASH is t if no prefix argument is given.
2224 With a prefix argument, TRASH is nil. */)
2225 (Lisp_Object filename
, Lisp_Object trash
)
2227 Lisp_Object handler
;
2228 Lisp_Object encoded_file
;
2229 struct gcpro gcpro1
;
2232 if (!NILP (Ffile_directory_p (filename
))
2233 && NILP (Ffile_symlink_p (filename
)))
2234 xsignal2 (Qfile_error
,
2235 build_string ("Removing old name: is a directory"),
2238 filename
= Fexpand_file_name (filename
, Qnil
);
2240 handler
= Ffind_file_name_handler (filename
, Qdelete_file
);
2241 if (!NILP (handler
))
2242 return call3 (handler
, Qdelete_file
, filename
, trash
);
2244 if (delete_by_moving_to_trash
&& !NILP (trash
))
2245 return call1 (Qmove_file_to_trash
, filename
);
2247 encoded_file
= ENCODE_FILE (filename
);
2249 if (unlink (SSDATA (encoded_file
)) < 0)
2250 report_file_error ("Removing old name", filename
);
2255 internal_delete_file_1 (Lisp_Object ignore
)
2260 /* Delete file FILENAME, returning true if successful.
2261 This ignores `delete-by-moving-to-trash'. */
2264 internal_delete_file (Lisp_Object filename
)
2268 tem
= internal_condition_case_2 (Fdelete_file
, filename
, Qnil
,
2269 Qt
, internal_delete_file_1
);
2273 DEFUN ("rename-file", Frename_file
, Srename_file
, 2, 3,
2274 "fRename file: \nGRename %s to file: \np",
2275 doc
: /* Rename FILE as NEWNAME. Both args must be strings.
2276 If file has names other than FILE, it continues to have those names.
2277 Signals a `file-already-exists' error if a file NEWNAME already exists
2278 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
2279 A number as third arg means request confirmation if NEWNAME already exists.
2280 This is what happens in interactive use with M-x. */)
2281 (Lisp_Object file
, Lisp_Object newname
, Lisp_Object ok_if_already_exists
)
2283 Lisp_Object handler
;
2284 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2285 Lisp_Object encoded_file
, encoded_newname
, symlink_target
;
2287 symlink_target
= encoded_file
= encoded_newname
= Qnil
;
2288 GCPRO5 (file
, newname
, encoded_file
, encoded_newname
, symlink_target
);
2289 CHECK_STRING (file
);
2290 CHECK_STRING (newname
);
2291 file
= Fexpand_file_name (file
, Qnil
);
2293 if ((!NILP (Ffile_directory_p (newname
)))
2295 /* If the file names are identical but for the case,
2296 don't attempt to move directory to itself. */
2297 && (NILP (Fstring_equal (Fdowncase (file
), Fdowncase (newname
))))
2301 Lisp_Object fname
= (NILP (Ffile_directory_p (file
))
2302 ? file
: Fdirectory_file_name (file
));
2303 newname
= Fexpand_file_name (Ffile_name_nondirectory (fname
), newname
);
2306 newname
= Fexpand_file_name (newname
, Qnil
);
2308 /* If the file name has special constructs in it,
2309 call the corresponding file handler. */
2310 handler
= Ffind_file_name_handler (file
, Qrename_file
);
2312 handler
= Ffind_file_name_handler (newname
, Qrename_file
);
2313 if (!NILP (handler
))
2314 RETURN_UNGCPRO (call4 (handler
, Qrename_file
,
2315 file
, newname
, ok_if_already_exists
));
2317 encoded_file
= ENCODE_FILE (file
);
2318 encoded_newname
= ENCODE_FILE (newname
);
2321 /* If the file names are identical but for the case, don't ask for
2322 confirmation: they simply want to change the letter-case of the
2324 if (NILP (Fstring_equal (Fdowncase (file
), Fdowncase (newname
))))
2326 if (NILP (ok_if_already_exists
)
2327 || INTEGERP (ok_if_already_exists
))
2328 barf_or_query_if_file_exists (newname
, "rename to it",
2329 INTEGERP (ok_if_already_exists
), 0, 0);
2330 if (rename (SSDATA (encoded_file
), SSDATA (encoded_newname
)) < 0)
2332 int rename_errno
= errno
;
2333 if (rename_errno
== EXDEV
)
2336 symlink_target
= Ffile_symlink_p (file
);
2337 if (! NILP (symlink_target
))
2338 Fmake_symbolic_link (symlink_target
, newname
,
2339 NILP (ok_if_already_exists
) ? Qnil
: Qt
);
2340 else if (!NILP (Ffile_directory_p (file
)))
2341 call4 (Qcopy_directory
, file
, newname
, Qt
, Qnil
);
2343 /* We have already prompted if it was an integer, so don't
2344 have copy-file prompt again. */
2345 Fcopy_file (file
, newname
,
2346 NILP (ok_if_already_exists
) ? Qnil
: Qt
,
2349 count
= SPECPDL_INDEX ();
2350 specbind (Qdelete_by_moving_to_trash
, Qnil
);
2352 if (!NILP (Ffile_directory_p (file
)) && NILP (symlink_target
))
2353 call2 (Qdelete_directory
, file
, Qt
);
2355 Fdelete_file (file
, Qnil
);
2356 unbind_to (count
, Qnil
);
2359 report_file_errno ("Renaming", list2 (file
, newname
), rename_errno
);
2365 DEFUN ("add-name-to-file", Fadd_name_to_file
, Sadd_name_to_file
, 2, 3,
2366 "fAdd name to file: \nGName to add to %s: \np",
2367 doc
: /* Give FILE additional name NEWNAME. Both args must be strings.
2368 Signals a `file-already-exists' error if a file NEWNAME already exists
2369 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
2370 A number as third arg means request confirmation if NEWNAME already exists.
2371 This is what happens in interactive use with M-x. */)
2372 (Lisp_Object file
, Lisp_Object newname
, Lisp_Object ok_if_already_exists
)
2374 Lisp_Object handler
;
2375 Lisp_Object encoded_file
, encoded_newname
;
2376 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2378 GCPRO4 (file
, newname
, encoded_file
, encoded_newname
);
2379 encoded_file
= encoded_newname
= Qnil
;
2380 CHECK_STRING (file
);
2381 CHECK_STRING (newname
);
2382 file
= Fexpand_file_name (file
, Qnil
);
2384 if (!NILP (Ffile_directory_p (newname
)))
2385 newname
= Fexpand_file_name (Ffile_name_nondirectory (file
), newname
);
2387 newname
= Fexpand_file_name (newname
, Qnil
);
2389 /* If the file name has special constructs in it,
2390 call the corresponding file handler. */
2391 handler
= Ffind_file_name_handler (file
, Qadd_name_to_file
);
2392 if (!NILP (handler
))
2393 RETURN_UNGCPRO (call4 (handler
, Qadd_name_to_file
, file
,
2394 newname
, ok_if_already_exists
));
2396 /* If the new name has special constructs in it,
2397 call the corresponding file handler. */
2398 handler
= Ffind_file_name_handler (newname
, Qadd_name_to_file
);
2399 if (!NILP (handler
))
2400 RETURN_UNGCPRO (call4 (handler
, Qadd_name_to_file
, file
,
2401 newname
, ok_if_already_exists
));
2403 encoded_file
= ENCODE_FILE (file
);
2404 encoded_newname
= ENCODE_FILE (newname
);
2406 if (NILP (ok_if_already_exists
)
2407 || INTEGERP (ok_if_already_exists
))
2408 barf_or_query_if_file_exists (newname
, "make it a new name",
2409 INTEGERP (ok_if_already_exists
), 0, 0);
2411 unlink (SSDATA (newname
));
2412 if (link (SSDATA (encoded_file
), SSDATA (encoded_newname
)) < 0)
2414 int link_errno
= errno
;
2415 report_file_errno ("Adding new name", list2 (file
, newname
), link_errno
);
2422 DEFUN ("make-symbolic-link", Fmake_symbolic_link
, Smake_symbolic_link
, 2, 3,
2423 "FMake symbolic link to file: \nGMake symbolic link to file %s: \np",
2424 doc
: /* Make a symbolic link to FILENAME, named LINKNAME.
2425 Both args must be strings.
2426 Signals a `file-already-exists' error if a file LINKNAME already exists
2427 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
2428 A number as third arg means request confirmation if LINKNAME already exists.
2429 This happens for interactive use with M-x. */)
2430 (Lisp_Object filename
, Lisp_Object linkname
, Lisp_Object ok_if_already_exists
)
2432 Lisp_Object handler
;
2433 Lisp_Object encoded_filename
, encoded_linkname
;
2434 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2436 GCPRO4 (filename
, linkname
, encoded_filename
, encoded_linkname
);
2437 encoded_filename
= encoded_linkname
= Qnil
;
2438 CHECK_STRING (filename
);
2439 CHECK_STRING (linkname
);
2440 /* If the link target has a ~, we must expand it to get
2441 a truly valid file name. Otherwise, do not expand;
2442 we want to permit links to relative file names. */
2443 if (SREF (filename
, 0) == '~')
2444 filename
= Fexpand_file_name (filename
, Qnil
);
2446 if (!NILP (Ffile_directory_p (linkname
)))
2447 linkname
= Fexpand_file_name (Ffile_name_nondirectory (filename
), linkname
);
2449 linkname
= Fexpand_file_name (linkname
, Qnil
);
2451 /* If the file name has special constructs in it,
2452 call the corresponding file handler. */
2453 handler
= Ffind_file_name_handler (filename
, Qmake_symbolic_link
);
2454 if (!NILP (handler
))
2455 RETURN_UNGCPRO (call4 (handler
, Qmake_symbolic_link
, filename
,
2456 linkname
, ok_if_already_exists
));
2458 /* If the new link name has special constructs in it,
2459 call the corresponding file handler. */
2460 handler
= Ffind_file_name_handler (linkname
, Qmake_symbolic_link
);
2461 if (!NILP (handler
))
2462 RETURN_UNGCPRO (call4 (handler
, Qmake_symbolic_link
, filename
,
2463 linkname
, ok_if_already_exists
));
2465 encoded_filename
= ENCODE_FILE (filename
);
2466 encoded_linkname
= ENCODE_FILE (linkname
);
2468 if (NILP (ok_if_already_exists
)
2469 || INTEGERP (ok_if_already_exists
))
2470 barf_or_query_if_file_exists (linkname
, "make it a link",
2471 INTEGERP (ok_if_already_exists
), 0, 0);
2472 if (symlink (SSDATA (encoded_filename
), SSDATA (encoded_linkname
)) < 0)
2474 /* If we didn't complain already, silently delete existing file. */
2476 if (errno
== EEXIST
)
2478 unlink (SSDATA (encoded_linkname
));
2479 if (symlink (SSDATA (encoded_filename
), SSDATA (encoded_linkname
))
2486 if (errno
== ENOSYS
)
2489 xsignal1 (Qfile_error
,
2490 build_string ("Symbolic links are not supported"));
2493 symlink_errno
= errno
;
2494 report_file_errno ("Making symbolic link", list2 (filename
, linkname
),
2502 DEFUN ("file-name-absolute-p", Ffile_name_absolute_p
, Sfile_name_absolute_p
,
2504 doc
: /* Return t if file FILENAME specifies an absolute file name.
2505 On Unix, this is a name starting with a `/' or a `~'. */)
2506 (Lisp_Object filename
)
2508 CHECK_STRING (filename
);
2509 return file_name_absolute_p (SSDATA (filename
)) ? Qt
: Qnil
;
2512 DEFUN ("file-exists-p", Ffile_exists_p
, Sfile_exists_p
, 1, 1, 0,
2513 doc
: /* Return t if file FILENAME exists (whether or not you can read it.)
2514 See also `file-readable-p' and `file-attributes'.
2515 This returns nil for a symlink to a nonexistent file.
2516 Use `file-symlink-p' to test for such links. */)
2517 (Lisp_Object filename
)
2519 Lisp_Object absname
;
2520 Lisp_Object handler
;
2522 CHECK_STRING (filename
);
2523 absname
= Fexpand_file_name (filename
, Qnil
);
2525 /* If the file name has special constructs in it,
2526 call the corresponding file handler. */
2527 handler
= Ffind_file_name_handler (absname
, Qfile_exists_p
);
2528 if (!NILP (handler
))
2530 Lisp_Object result
= call2 (handler
, Qfile_exists_p
, absname
);
2535 absname
= ENCODE_FILE (absname
);
2537 return check_existing (SSDATA (absname
)) ? Qt
: Qnil
;
2540 DEFUN ("file-executable-p", Ffile_executable_p
, Sfile_executable_p
, 1, 1, 0,
2541 doc
: /* Return t if FILENAME can be executed by you.
2542 For a directory, this means you can access files in that directory. */)
2543 (Lisp_Object filename
)
2545 Lisp_Object absname
;
2546 Lisp_Object handler
;
2548 CHECK_STRING (filename
);
2549 absname
= Fexpand_file_name (filename
, Qnil
);
2551 /* If the file name has special constructs in it,
2552 call the corresponding file handler. */
2553 handler
= Ffind_file_name_handler (absname
, Qfile_executable_p
);
2554 if (!NILP (handler
))
2555 return call2 (handler
, Qfile_executable_p
, absname
);
2557 absname
= ENCODE_FILE (absname
);
2559 return (check_executable (SSDATA (absname
)) ? Qt
: Qnil
);
2562 DEFUN ("file-readable-p", Ffile_readable_p
, Sfile_readable_p
, 1, 1, 0,
2563 doc
: /* Return t if file FILENAME exists and you can read it.
2564 See also `file-exists-p' and `file-attributes'. */)
2565 (Lisp_Object filename
)
2567 Lisp_Object absname
;
2568 Lisp_Object handler
;
2570 CHECK_STRING (filename
);
2571 absname
= Fexpand_file_name (filename
, Qnil
);
2573 /* If the file name has special constructs in it,
2574 call the corresponding file handler. */
2575 handler
= Ffind_file_name_handler (absname
, Qfile_readable_p
);
2576 if (!NILP (handler
))
2577 return call2 (handler
, Qfile_readable_p
, absname
);
2579 absname
= ENCODE_FILE (absname
);
2580 return (faccessat (AT_FDCWD
, SSDATA (absname
), R_OK
, AT_EACCESS
) == 0
2584 DEFUN ("file-writable-p", Ffile_writable_p
, Sfile_writable_p
, 1, 1, 0,
2585 doc
: /* Return t if file FILENAME can be written or created by you. */)
2586 (Lisp_Object filename
)
2588 Lisp_Object absname
, dir
, encoded
;
2589 Lisp_Object handler
;
2591 CHECK_STRING (filename
);
2592 absname
= Fexpand_file_name (filename
, Qnil
);
2594 /* If the file name has special constructs in it,
2595 call the corresponding file handler. */
2596 handler
= Ffind_file_name_handler (absname
, Qfile_writable_p
);
2597 if (!NILP (handler
))
2598 return call2 (handler
, Qfile_writable_p
, absname
);
2600 encoded
= ENCODE_FILE (absname
);
2601 if (check_writable (SSDATA (encoded
), W_OK
))
2603 if (errno
!= ENOENT
)
2606 dir
= Ffile_name_directory (absname
);
2607 eassert (!NILP (dir
));
2609 dir
= Fdirectory_file_name (dir
);
2612 dir
= ENCODE_FILE (dir
);
2614 /* The read-only attribute of the parent directory doesn't affect
2615 whether a file or directory can be created within it. Some day we
2616 should check ACLs though, which do affect this. */
2617 return file_directory_p (SDATA (dir
)) ? Qt
: Qnil
;
2619 return check_writable (SSDATA (dir
), W_OK
| X_OK
) ? Qt
: Qnil
;
2623 DEFUN ("access-file", Faccess_file
, Saccess_file
, 2, 2, 0,
2624 doc
: /* Access file FILENAME, and get an error if that does not work.
2625 The second argument STRING is used in the error message.
2626 If there is no error, returns nil. */)
2627 (Lisp_Object filename
, Lisp_Object string
)
2629 Lisp_Object handler
, encoded_filename
, absname
;
2631 CHECK_STRING (filename
);
2632 absname
= Fexpand_file_name (filename
, Qnil
);
2634 CHECK_STRING (string
);
2636 /* If the file name has special constructs in it,
2637 call the corresponding file handler. */
2638 handler
= Ffind_file_name_handler (absname
, Qaccess_file
);
2639 if (!NILP (handler
))
2640 return call3 (handler
, Qaccess_file
, absname
, string
);
2642 encoded_filename
= ENCODE_FILE (absname
);
2644 if (faccessat (AT_FDCWD
, SSDATA (encoded_filename
), R_OK
, AT_EACCESS
) != 0)
2645 report_file_error (SSDATA (string
), filename
);
2650 /* Relative to directory FD, return the symbolic link value of FILENAME.
2651 On failure, return nil. */
2653 emacs_readlinkat (int fd
, char const *filename
)
2655 static struct allocator
const emacs_norealloc_allocator
=
2656 { xmalloc
, NULL
, xfree
, memory_full
};
2658 char readlink_buf
[1024];
2659 char *buf
= careadlinkat (fd
, filename
, readlink_buf
, sizeof readlink_buf
,
2660 &emacs_norealloc_allocator
, readlinkat
);
2664 val
= build_string (buf
);
2665 if (buf
[0] == '/' && strchr (buf
, ':'))
2666 val
= concat2 (build_string ("/:"), val
);
2667 if (buf
!= readlink_buf
)
2669 val
= DECODE_FILE (val
);
2673 DEFUN ("file-symlink-p", Ffile_symlink_p
, Sfile_symlink_p
, 1, 1, 0,
2674 doc
: /* Return non-nil if file FILENAME is the name of a symbolic link.
2675 The value is the link target, as a string.
2676 Otherwise it returns nil.
2678 This function returns t when given the name of a symlink that
2679 points to a nonexistent file. */)
2680 (Lisp_Object filename
)
2682 Lisp_Object handler
;
2684 CHECK_STRING (filename
);
2685 filename
= Fexpand_file_name (filename
, Qnil
);
2687 /* If the file name has special constructs in it,
2688 call the corresponding file handler. */
2689 handler
= Ffind_file_name_handler (filename
, Qfile_symlink_p
);
2690 if (!NILP (handler
))
2691 return call2 (handler
, Qfile_symlink_p
, filename
);
2693 filename
= ENCODE_FILE (filename
);
2695 return emacs_readlinkat (AT_FDCWD
, SSDATA (filename
));
2698 DEFUN ("file-directory-p", Ffile_directory_p
, Sfile_directory_p
, 1, 1, 0,
2699 doc
: /* Return t if FILENAME names an existing directory.
2700 Symbolic links to directories count as directories.
2701 See `file-symlink-p' to distinguish symlinks. */)
2702 (Lisp_Object filename
)
2704 Lisp_Object absname
;
2705 Lisp_Object handler
;
2707 absname
= expand_and_dir_to_file (filename
, BVAR (current_buffer
, directory
));
2709 /* If the file name has special constructs in it,
2710 call the corresponding file handler. */
2711 handler
= Ffind_file_name_handler (absname
, Qfile_directory_p
);
2712 if (!NILP (handler
))
2713 return call2 (handler
, Qfile_directory_p
, absname
);
2715 absname
= ENCODE_FILE (absname
);
2717 return file_directory_p (SSDATA (absname
)) ? Qt
: Qnil
;
2720 /* Return true if FILE is a directory or a symlink to a directory. */
2722 file_directory_p (char const *file
)
2725 /* This is cheaper than 'stat'. */
2726 return faccessat (AT_FDCWD
, file
, D_OK
, AT_EACCESS
) == 0;
2729 return stat (file
, &st
) == 0 && S_ISDIR (st
.st_mode
);
2733 DEFUN ("file-accessible-directory-p", Ffile_accessible_directory_p
,
2734 Sfile_accessible_directory_p
, 1, 1, 0,
2735 doc
: /* Return t if file FILENAME names a directory you can open.
2736 For the value to be t, FILENAME must specify the name of a directory as a file,
2737 and the directory must allow you to open files in it. In order to use a
2738 directory as a buffer's current directory, this predicate must return true.
2739 A directory name spec may be given instead; then the value is t
2740 if the directory so specified exists and really is a readable and
2741 searchable directory. */)
2742 (Lisp_Object filename
)
2744 Lisp_Object absname
;
2745 Lisp_Object handler
;
2747 CHECK_STRING (filename
);
2748 absname
= Fexpand_file_name (filename
, Qnil
);
2750 /* If the file name has special constructs in it,
2751 call the corresponding file handler. */
2752 handler
= Ffind_file_name_handler (absname
, Qfile_accessible_directory_p
);
2753 if (!NILP (handler
))
2755 Lisp_Object r
= call2 (handler
, Qfile_accessible_directory_p
, absname
);
2760 absname
= ENCODE_FILE (absname
);
2761 return file_accessible_directory_p (SSDATA (absname
)) ? Qt
: Qnil
;
2764 /* If FILE is a searchable directory or a symlink to a
2765 searchable directory, return true. Otherwise return
2766 false and set errno to an error number. */
2768 file_accessible_directory_p (char const *file
)
2771 /* There's no need to test whether FILE is searchable, as the
2772 searchable/executable bit is invented on DOS_NT platforms. */
2773 return file_directory_p (file
);
2775 /* On POSIXish platforms, use just one system call; this avoids a
2776 race and is typically faster. */
2777 ptrdiff_t len
= strlen (file
);
2783 /* Normally a file "FOO" is an accessible directory if "FOO/." exists.
2784 There are three exceptions: "", "/", and "//". Leave "" alone,
2785 as it's invalid. Append only "." to the other two exceptions as
2786 "/" and "//" are distinct on some platforms, whereas "/", "///",
2787 "////", etc. are all equivalent. */
2792 /* Just check for trailing '/' when deciding whether to append '/'.
2793 That's simpler than testing the two special cases "/" and "//",
2794 and it's a safe optimization here. */
2795 char *buf
= SAFE_ALLOCA (len
+ 3);
2796 memcpy (buf
, file
, len
);
2797 strcpy (buf
+ len
, &"/."[file
[len
- 1] == '/']);
2801 ok
= check_existing (dir
);
2802 saved_errno
= errno
;
2804 errno
= saved_errno
;
2809 DEFUN ("file-regular-p", Ffile_regular_p
, Sfile_regular_p
, 1, 1, 0,
2810 doc
: /* Return t if FILENAME names a regular file.
2811 This is the sort of file that holds an ordinary stream of data bytes.
2812 Symbolic links to regular files count as regular files.
2813 See `file-symlink-p' to distinguish symlinks. */)
2814 (Lisp_Object filename
)
2816 register Lisp_Object absname
;
2818 Lisp_Object handler
;
2820 absname
= expand_and_dir_to_file (filename
, BVAR (current_buffer
, directory
));
2822 /* If the file name has special constructs in it,
2823 call the corresponding file handler. */
2824 handler
= Ffind_file_name_handler (absname
, Qfile_regular_p
);
2825 if (!NILP (handler
))
2826 return call2 (handler
, Qfile_regular_p
, absname
);
2828 absname
= ENCODE_FILE (absname
);
2833 Lisp_Object tem
= Vw32_get_true_file_attributes
;
2835 /* Tell stat to use expensive method to get accurate info. */
2836 Vw32_get_true_file_attributes
= Qt
;
2837 result
= stat (SDATA (absname
), &st
);
2838 Vw32_get_true_file_attributes
= tem
;
2842 return S_ISREG (st
.st_mode
) ? Qt
: Qnil
;
2845 if (stat (SSDATA (absname
), &st
) < 0)
2847 return S_ISREG (st
.st_mode
) ? Qt
: Qnil
;
2851 DEFUN ("file-selinux-context", Ffile_selinux_context
,
2852 Sfile_selinux_context
, 1, 1, 0,
2853 doc
: /* Return SELinux context of file named FILENAME.
2854 The return value is a list (USER ROLE TYPE RANGE), where the list
2855 elements are strings naming the user, role, type, and range of the
2856 file's SELinux security context.
2858 Return (nil nil nil nil) if the file is nonexistent or inaccessible,
2859 or if SELinux is disabled, or if Emacs lacks SELinux support. */)
2860 (Lisp_Object filename
)
2862 Lisp_Object absname
;
2863 Lisp_Object values
[4];
2864 Lisp_Object handler
;
2866 security_context_t con
;
2871 absname
= expand_and_dir_to_file (filename
, BVAR (current_buffer
, directory
));
2873 /* If the file name has special constructs in it,
2874 call the corresponding file handler. */
2875 handler
= Ffind_file_name_handler (absname
, Qfile_selinux_context
);
2876 if (!NILP (handler
))
2877 return call2 (handler
, Qfile_selinux_context
, absname
);
2879 absname
= ENCODE_FILE (absname
);
2886 if (is_selinux_enabled ())
2888 conlength
= lgetfilecon (SSDATA (absname
), &con
);
2891 context
= context_new (con
);
2892 if (context_user_get (context
))
2893 values
[0] = build_string (context_user_get (context
));
2894 if (context_role_get (context
))
2895 values
[1] = build_string (context_role_get (context
));
2896 if (context_type_get (context
))
2897 values
[2] = build_string (context_type_get (context
));
2898 if (context_range_get (context
))
2899 values
[3] = build_string (context_range_get (context
));
2900 context_free (context
);
2906 return Flist (sizeof (values
) / sizeof (values
[0]), values
);
2909 DEFUN ("set-file-selinux-context", Fset_file_selinux_context
,
2910 Sset_file_selinux_context
, 2, 2, 0,
2911 doc
: /* Set SELinux context of file named FILENAME to CONTEXT.
2912 CONTEXT should be a list (USER ROLE TYPE RANGE), where the list
2913 elements are strings naming the components of a SELinux context.
2915 Value is t if setting of SELinux context was successful, nil otherwise.
2917 This function does nothing and returns nil if SELinux is disabled,
2918 or if Emacs was not compiled with SELinux support. */)
2919 (Lisp_Object filename
, Lisp_Object context
)
2921 Lisp_Object absname
;
2922 Lisp_Object handler
;
2924 Lisp_Object encoded_absname
;
2925 Lisp_Object user
= CAR_SAFE (context
);
2926 Lisp_Object role
= CAR_SAFE (CDR_SAFE (context
));
2927 Lisp_Object type
= CAR_SAFE (CDR_SAFE (CDR_SAFE (context
)));
2928 Lisp_Object range
= CAR_SAFE (CDR_SAFE (CDR_SAFE (CDR_SAFE (context
))));
2929 security_context_t con
;
2932 context_t parsed_con
;
2935 absname
= Fexpand_file_name (filename
, BVAR (current_buffer
, directory
));
2937 /* If the file name has special constructs in it,
2938 call the corresponding file handler. */
2939 handler
= Ffind_file_name_handler (absname
, Qset_file_selinux_context
);
2940 if (!NILP (handler
))
2941 return call3 (handler
, Qset_file_selinux_context
, absname
, context
);
2944 if (is_selinux_enabled ())
2946 /* Get current file context. */
2947 encoded_absname
= ENCODE_FILE (absname
);
2948 conlength
= lgetfilecon (SSDATA (encoded_absname
), &con
);
2951 parsed_con
= context_new (con
);
2952 /* Change the parts defined in the parameter.*/
2955 if (context_user_set (parsed_con
, SSDATA (user
)))
2956 error ("Doing context_user_set");
2960 if (context_role_set (parsed_con
, SSDATA (role
)))
2961 error ("Doing context_role_set");
2965 if (context_type_set (parsed_con
, SSDATA (type
)))
2966 error ("Doing context_type_set");
2968 if (STRINGP (range
))
2970 if (context_range_set (parsed_con
, SSDATA (range
)))
2971 error ("Doing context_range_set");
2974 /* Set the modified context back to the file. */
2975 fail
= (lsetfilecon (SSDATA (encoded_absname
),
2976 context_str (parsed_con
))
2978 /* See http://debbugs.gnu.org/11245 for ENOTSUP. */
2979 if (fail
&& errno
!= ENOTSUP
)
2980 report_file_error ("Doing lsetfilecon", absname
);
2982 context_free (parsed_con
);
2984 return fail
? Qnil
: Qt
;
2987 report_file_error ("Doing lgetfilecon", absname
);
2994 DEFUN ("file-acl", Ffile_acl
, Sfile_acl
, 1, 1, 0,
2995 doc
: /* Return ACL entries of file named FILENAME.
2996 The entries are returned in a format suitable for use in `set-file-acl'
2997 but is otherwise undocumented and subject to change.
2998 Return nil if file does not exist or is not accessible, or if Emacs
2999 was unable to determine the ACL entries. */)
3000 (Lisp_Object filename
)
3002 Lisp_Object absname
;
3003 Lisp_Object handler
;
3004 #ifdef HAVE_ACL_SET_FILE
3006 Lisp_Object acl_string
;
3010 absname
= expand_and_dir_to_file (filename
,
3011 BVAR (current_buffer
, directory
));
3013 /* If the file name has special constructs in it,
3014 call the corresponding file handler. */
3015 handler
= Ffind_file_name_handler (absname
, Qfile_acl
);
3016 if (!NILP (handler
))
3017 return call2 (handler
, Qfile_acl
, absname
);
3019 #ifdef HAVE_ACL_SET_FILE
3020 absname
= ENCODE_FILE (absname
);
3022 acl
= acl_get_file (SSDATA (absname
), ACL_TYPE_ACCESS
);
3026 str
= acl_to_text (acl
, NULL
);
3033 acl_string
= build_string (str
);
3043 DEFUN ("set-file-acl", Fset_file_acl
, Sset_file_acl
,
3045 doc
: /* Set ACL of file named FILENAME to ACL-STRING.
3046 ACL-STRING should contain the textual representation of the ACL
3047 entries in a format suitable for the platform.
3049 Value is t if setting of ACL was successful, nil otherwise.
3051 Setting ACL for local files requires Emacs to be built with ACL
3053 (Lisp_Object filename
, Lisp_Object acl_string
)
3055 Lisp_Object absname
;
3056 Lisp_Object handler
;
3057 #ifdef HAVE_ACL_SET_FILE
3058 Lisp_Object encoded_absname
;
3063 absname
= Fexpand_file_name (filename
, BVAR (current_buffer
, directory
));
3065 /* If the file name has special constructs in it,
3066 call the corresponding file handler. */
3067 handler
= Ffind_file_name_handler (absname
, Qset_file_acl
);
3068 if (!NILP (handler
))
3069 return call3 (handler
, Qset_file_acl
, absname
, acl_string
);
3071 #ifdef HAVE_ACL_SET_FILE
3072 if (STRINGP (acl_string
))
3074 acl
= acl_from_text (SSDATA (acl_string
));
3077 report_file_error ("Converting ACL", absname
);
3081 encoded_absname
= ENCODE_FILE (absname
);
3083 fail
= (acl_set_file (SSDATA (encoded_absname
), ACL_TYPE_ACCESS
,
3086 if (fail
&& acl_errno_valid (errno
))
3087 report_file_error ("Setting ACL", absname
);
3090 return fail
? Qnil
: Qt
;
3097 DEFUN ("file-modes", Ffile_modes
, Sfile_modes
, 1, 1, 0,
3098 doc
: /* Return mode bits of file named FILENAME, as an integer.
3099 Return nil, if file does not exist or is not accessible. */)
3100 (Lisp_Object filename
)
3102 Lisp_Object absname
;
3104 Lisp_Object handler
;
3106 absname
= expand_and_dir_to_file (filename
, BVAR (current_buffer
, directory
));
3108 /* If the file name has special constructs in it,
3109 call the corresponding file handler. */
3110 handler
= Ffind_file_name_handler (absname
, Qfile_modes
);
3111 if (!NILP (handler
))
3112 return call2 (handler
, Qfile_modes
, absname
);
3114 absname
= ENCODE_FILE (absname
);
3116 if (stat (SSDATA (absname
), &st
) < 0)
3119 return make_number (st
.st_mode
& 07777);
3122 DEFUN ("set-file-modes", Fset_file_modes
, Sset_file_modes
, 2, 2,
3123 "(let ((file (read-file-name \"File: \"))) \
3124 (list file (read-file-modes nil file)))",
3125 doc
: /* Set mode bits of file named FILENAME to MODE (an integer).
3126 Only the 12 low bits of MODE are used.
3128 Interactively, mode bits are read by `read-file-modes', which accepts
3129 symbolic notation, like the `chmod' command from GNU Coreutils. */)
3130 (Lisp_Object filename
, Lisp_Object mode
)
3132 Lisp_Object absname
, encoded_absname
;
3133 Lisp_Object handler
;
3135 absname
= Fexpand_file_name (filename
, BVAR (current_buffer
, directory
));
3136 CHECK_NUMBER (mode
);
3138 /* If the file name has special constructs in it,
3139 call the corresponding file handler. */
3140 handler
= Ffind_file_name_handler (absname
, Qset_file_modes
);
3141 if (!NILP (handler
))
3142 return call3 (handler
, Qset_file_modes
, absname
, mode
);
3144 encoded_absname
= ENCODE_FILE (absname
);
3146 if (chmod (SSDATA (encoded_absname
), XINT (mode
) & 07777) < 0)
3147 report_file_error ("Doing chmod", absname
);
3152 DEFUN ("set-default-file-modes", Fset_default_file_modes
, Sset_default_file_modes
, 1, 1, 0,
3153 doc
: /* Set the file permission bits for newly created files.
3154 The argument MODE should be an integer; only the low 9 bits are used.
3155 This setting is inherited by subprocesses. */)
3158 CHECK_NUMBER (mode
);
3160 umask ((~ XINT (mode
)) & 0777);
3165 DEFUN ("default-file-modes", Fdefault_file_modes
, Sdefault_file_modes
, 0, 0, 0,
3166 doc
: /* Return the default file protection for created files.
3167 The value is an integer. */)
3174 realmask
= umask (0);
3178 XSETINT (value
, (~ realmask
) & 0777);
3183 DEFUN ("set-file-times", Fset_file_times
, Sset_file_times
, 1, 2, 0,
3184 doc
: /* Set times of file FILENAME to TIMESTAMP.
3185 Set both access and modification times.
3186 Return t on success, else nil.
3187 Use the current time if TIMESTAMP is nil. TIMESTAMP is in the format of
3189 (Lisp_Object filename
, Lisp_Object timestamp
)
3191 Lisp_Object absname
, encoded_absname
;
3192 Lisp_Object handler
;
3193 struct timespec t
= lisp_time_argument (timestamp
);
3195 absname
= Fexpand_file_name (filename
, BVAR (current_buffer
, directory
));
3197 /* If the file name has special constructs in it,
3198 call the corresponding file handler. */
3199 handler
= Ffind_file_name_handler (absname
, Qset_file_times
);
3200 if (!NILP (handler
))
3201 return call3 (handler
, Qset_file_times
, absname
, timestamp
);
3203 encoded_absname
= ENCODE_FILE (absname
);
3206 if (set_file_times (-1, SSDATA (encoded_absname
), t
, t
))
3209 /* Setting times on a directory always fails. */
3210 if (file_directory_p (SSDATA (encoded_absname
)))
3213 report_file_error ("Setting file times", absname
);
3221 DEFUN ("unix-sync", Funix_sync
, Sunix_sync
, 0, 0, "",
3222 doc
: /* Tell Unix to finish all pending disk updates. */)
3229 #endif /* HAVE_SYNC */
3231 DEFUN ("file-newer-than-file-p", Ffile_newer_than_file_p
, Sfile_newer_than_file_p
, 2, 2, 0,
3232 doc
: /* Return t if file FILE1 is newer than file FILE2.
3233 If FILE1 does not exist, the answer is nil;
3234 otherwise, if FILE2 does not exist, the answer is t. */)
3235 (Lisp_Object file1
, Lisp_Object file2
)
3237 Lisp_Object absname1
, absname2
;
3238 struct stat st1
, st2
;
3239 Lisp_Object handler
;
3240 struct gcpro gcpro1
, gcpro2
;
3242 CHECK_STRING (file1
);
3243 CHECK_STRING (file2
);
3246 GCPRO2 (absname1
, file2
);
3247 absname1
= expand_and_dir_to_file (file1
, BVAR (current_buffer
, directory
));
3248 absname2
= expand_and_dir_to_file (file2
, BVAR (current_buffer
, directory
));
3251 /* If the file name has special constructs in it,
3252 call the corresponding file handler. */
3253 handler
= Ffind_file_name_handler (absname1
, Qfile_newer_than_file_p
);
3255 handler
= Ffind_file_name_handler (absname2
, Qfile_newer_than_file_p
);
3256 if (!NILP (handler
))
3257 return call3 (handler
, Qfile_newer_than_file_p
, absname1
, absname2
);
3259 GCPRO2 (absname1
, absname2
);
3260 absname1
= ENCODE_FILE (absname1
);
3261 absname2
= ENCODE_FILE (absname2
);
3264 if (stat (SSDATA (absname1
), &st1
) < 0)
3267 if (stat (SSDATA (absname2
), &st2
) < 0)
3270 return (timespec_cmp (get_stat_mtime (&st2
), get_stat_mtime (&st1
)) < 0
3274 #ifndef READ_BUF_SIZE
3275 #define READ_BUF_SIZE (64 << 10)
3277 /* Some buffer offsets are stored in 'int' variables. */
3278 verify (READ_BUF_SIZE
<= INT_MAX
);
3280 /* This function is called after Lisp functions to decide a coding
3281 system are called, or when they cause an error. Before they are
3282 called, the current buffer is set unibyte and it contains only a
3283 newly inserted text (thus the buffer was empty before the
3286 The functions may set markers, overlays, text properties, or even
3287 alter the buffer contents, change the current buffer.
3289 Here, we reset all those changes by:
3290 o set back the current buffer.
3291 o move all markers and overlays to BEG.
3292 o remove all text properties.
3293 o set back the buffer multibyteness. */
3296 decide_coding_unwind (Lisp_Object unwind_data
)
3298 Lisp_Object multibyte
, undo_list
, buffer
;
3300 multibyte
= XCAR (unwind_data
);
3301 unwind_data
= XCDR (unwind_data
);
3302 undo_list
= XCAR (unwind_data
);
3303 buffer
= XCDR (unwind_data
);
3305 set_buffer_internal (XBUFFER (buffer
));
3306 adjust_markers_for_delete (BEG
, BEG_BYTE
, Z
, Z_BYTE
);
3307 adjust_overlays_for_delete (BEG
, Z
- BEG
);
3308 set_buffer_intervals (current_buffer
, NULL
);
3309 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
3311 /* Now we are safe to change the buffer's multibyteness directly. */
3312 bset_enable_multibyte_characters (current_buffer
, multibyte
);
3313 bset_undo_list (current_buffer
, undo_list
);
3316 /* Read from a non-regular file. STATE is a Lisp_Save_Value
3317 object where slot 0 is the file descriptor, slot 1 specifies
3318 an offset to put the read bytes, and slot 2 is the maximum
3319 amount of bytes to read. Value is the number of bytes read. */
3322 read_non_regular (Lisp_Object state
)
3328 nbytes
= emacs_read (XSAVE_INTEGER (state
, 0),
3329 ((char *) BEG_ADDR
+ PT_BYTE
- BEG_BYTE
3330 + XSAVE_INTEGER (state
, 1)),
3331 XSAVE_INTEGER (state
, 2));
3333 /* Fast recycle this object for the likely next call. */
3335 return make_number (nbytes
);
3339 /* Condition-case handler used when reading from non-regular files
3340 in insert-file-contents. */
3343 read_non_regular_quit (Lisp_Object ignore
)
3348 /* Return the file offset that VAL represents, checking for type
3349 errors and overflow. */
3351 file_offset (Lisp_Object val
)
3353 if (RANGED_INTEGERP (0, val
, TYPE_MAXIMUM (off_t
)))
3358 double v
= XFLOAT_DATA (val
);
3360 && (sizeof (off_t
) < sizeof v
3361 ? v
<= TYPE_MAXIMUM (off_t
)
3362 : v
< TYPE_MAXIMUM (off_t
)))
3366 wrong_type_argument (intern ("file-offset"), val
);
3369 /* Return a special time value indicating the error number ERRNUM. */
3370 static struct timespec
3371 time_error_value (int errnum
)
3373 int ns
= (errnum
== ENOENT
|| errnum
== EACCES
|| errnum
== ENOTDIR
3374 ? NONEXISTENT_MODTIME_NSECS
3375 : UNKNOWN_MODTIME_NSECS
);
3376 return make_timespec (0, ns
);
3379 DEFUN ("insert-file-contents", Finsert_file_contents
, Sinsert_file_contents
,
3381 doc
: /* Insert contents of file FILENAME after point.
3382 Returns list of absolute file name and number of characters inserted.
3383 If second argument VISIT is non-nil, the buffer's visited filename and
3384 last save file modtime are set, and it is marked unmodified. If
3385 visiting and the file does not exist, visiting is completed before the
3388 The optional third and fourth arguments BEG and END specify what portion
3389 of the file to insert. These arguments count bytes in the file, not
3390 characters in the buffer. If VISIT is non-nil, BEG and END must be nil.
3392 If optional fifth argument REPLACE is non-nil, replace the current
3393 buffer contents (in the accessible portion) with the file contents.
3394 This is better than simply deleting and inserting the whole thing
3395 because (1) it preserves some marker positions and (2) it puts less data
3396 in the undo list. When REPLACE is non-nil, the second return value is
3397 the number of characters that replace previous buffer contents.
3399 This function does code conversion according to the value of
3400 `coding-system-for-read' or `file-coding-system-alist', and sets the
3401 variable `last-coding-system-used' to the coding system actually used.
3403 In addition, this function decodes the inserted text from known formats
3404 by calling `format-decode', which see. */)
3405 (Lisp_Object filename
, Lisp_Object visit
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object replace
)
3408 struct timespec mtime
;
3410 ptrdiff_t inserted
= 0;
3412 off_t beg_offset
, end_offset
;
3414 ptrdiff_t count
= SPECPDL_INDEX ();
3415 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
3416 Lisp_Object handler
, val
, insval
, orig_filename
, old_undo
;
3418 ptrdiff_t total
= 0;
3419 bool not_regular
= 0;
3421 char read_buf
[READ_BUF_SIZE
];
3422 struct coding_system coding
;
3423 bool replace_handled
= 0;
3424 bool set_coding_system
= 0;
3425 Lisp_Object coding_system
;
3427 /* If the undo log only contains the insertion, there's no point
3428 keeping it. It's typically when we first fill a file-buffer. */
3429 bool empty_undo_list_p
3430 = (!NILP (visit
) && NILP (BVAR (current_buffer
, undo_list
))
3432 Lisp_Object old_Vdeactivate_mark
= Vdeactivate_mark
;
3433 bool we_locked_file
= 0;
3436 if (current_buffer
->base_buffer
&& ! NILP (visit
))
3437 error ("Cannot do file visiting in an indirect buffer");
3439 if (!NILP (BVAR (current_buffer
, read_only
)))
3440 Fbarf_if_buffer_read_only ();
3444 orig_filename
= Qnil
;
3447 GCPRO5 (filename
, val
, p
, orig_filename
, old_undo
);
3449 CHECK_STRING (filename
);
3450 filename
= Fexpand_file_name (filename
, Qnil
);
3452 /* The value Qnil means that the coding system is not yet
3454 coding_system
= Qnil
;
3456 /* If the file name has special constructs in it,
3457 call the corresponding file handler. */
3458 handler
= Ffind_file_name_handler (filename
, Qinsert_file_contents
);
3459 if (!NILP (handler
))
3461 val
= call6 (handler
, Qinsert_file_contents
, filename
,
3462 visit
, beg
, end
, replace
);
3463 if (CONSP (val
) && CONSP (XCDR (val
))
3464 && RANGED_INTEGERP (0, XCAR (XCDR (val
)), ZV
- PT
))
3465 inserted
= XINT (XCAR (XCDR (val
)));
3469 orig_filename
= filename
;
3470 filename
= ENCODE_FILE (filename
);
3472 fd
= emacs_open (SSDATA (filename
), O_RDONLY
, 0);
3477 report_file_error ("Opening input file", orig_filename
);
3478 mtime
= time_error_value (save_errno
);
3480 if (!NILP (Vcoding_system_for_read
))
3481 Fset (Qbuffer_file_coding_system
, Vcoding_system_for_read
);
3485 fd_index
= SPECPDL_INDEX ();
3486 record_unwind_protect_int (close_file_unwind
, fd
);
3488 /* Replacement should preserve point as it preserves markers. */
3489 if (!NILP (replace
))
3490 record_unwind_protect (restore_point_unwind
, Fpoint_marker ());
3492 if (fstat (fd
, &st
) != 0)
3493 report_file_error ("Input file status", orig_filename
);
3494 mtime
= get_stat_mtime (&st
);
3496 /* This code will need to be changed in order to work on named
3497 pipes, and it's probably just not worth it. So we should at
3498 least signal an error. */
3499 if (!S_ISREG (st
.st_mode
))
3506 if (! NILP (replace
) || ! NILP (beg
) || ! NILP (end
))
3507 xsignal2 (Qfile_error
,
3508 build_string ("not a regular file"), orig_filename
);
3513 if (!NILP (beg
) || !NILP (end
))
3514 error ("Attempt to visit less than an entire file");
3515 if (BEG
< Z
&& NILP (replace
))
3516 error ("Cannot do file visiting in a non-empty buffer");
3520 beg_offset
= file_offset (beg
);
3525 end_offset
= file_offset (end
);
3529 end_offset
= TYPE_MAXIMUM (off_t
);
3532 end_offset
= st
.st_size
;
3534 /* A negative size can happen on a platform that allows file
3535 sizes greater than the maximum off_t value. */
3539 /* The file size returned from stat may be zero, but data
3540 may be readable nonetheless, for example when this is a
3541 file in the /proc filesystem. */
3542 if (end_offset
== 0)
3543 end_offset
= READ_BUF_SIZE
;
3547 /* Check now whether the buffer will become too large,
3548 in the likely case where the file's length is not changing.
3549 This saves a lot of needless work before a buffer overflow. */
3552 /* The likely offset where we will stop reading. We could read
3553 more (or less), if the file grows (or shrinks) as we read it. */
3554 off_t likely_end
= min (end_offset
, st
.st_size
);
3556 if (beg_offset
< likely_end
)
3559 = Z_BYTE
- (!NILP (replace
) ? ZV_BYTE
- BEGV_BYTE
: 0);
3560 ptrdiff_t buf_growth_max
= BUF_BYTES_MAX
- buf_bytes
;
3561 off_t likely_growth
= likely_end
- beg_offset
;
3562 if (buf_growth_max
< likely_growth
)
3567 /* Prevent redisplay optimizations. */
3568 current_buffer
->clip_changed
= 1;
3570 if (EQ (Vcoding_system_for_read
, Qauto_save_coding
))
3572 coding_system
= coding_inherit_eol_type (Qutf_8_emacs
, Qunix
);
3573 setup_coding_system (coding_system
, &coding
);
3574 /* Ensure we set Vlast_coding_system_used. */
3575 set_coding_system
= 1;
3579 /* Decide the coding system to use for reading the file now
3580 because we can't use an optimized method for handling
3581 `coding:' tag if the current buffer is not empty. */
3582 if (!NILP (Vcoding_system_for_read
))
3583 coding_system
= Vcoding_system_for_read
;
3586 /* Don't try looking inside a file for a coding system
3587 specification if it is not seekable. */
3588 if (! not_regular
&& ! NILP (Vset_auto_coding_function
))
3590 /* Find a coding system specified in the heading two
3591 lines or in the tailing several lines of the file.
3592 We assume that the 1K-byte and 3K-byte for heading
3593 and tailing respectively are sufficient for this
3597 if (st
.st_size
<= (1024 * 4))
3598 nread
= emacs_read (fd
, read_buf
, 1024 * 4);
3601 nread
= emacs_read (fd
, read_buf
, 1024);
3605 if (lseek (fd
, - (1024 * 3), SEEK_END
) < 0)
3606 report_file_error ("Setting file position",
3608 ntail
= emacs_read (fd
, read_buf
+ nread
, 1024 * 3);
3609 nread
= ntail
< 0 ? ntail
: nread
+ ntail
;
3614 report_file_error ("Read error", orig_filename
);
3617 struct buffer
*prev
= current_buffer
;
3618 Lisp_Object workbuf
;
3621 record_unwind_current_buffer ();
3623 workbuf
= Fget_buffer_create (build_string (" *code-converting-work*"));
3624 buf
= XBUFFER (workbuf
);
3626 delete_all_overlays (buf
);
3627 bset_directory (buf
, BVAR (current_buffer
, directory
));
3628 bset_read_only (buf
, Qnil
);
3629 bset_filename (buf
, Qnil
);
3630 bset_undo_list (buf
, Qt
);
3631 eassert (buf
->overlays_before
== NULL
);
3632 eassert (buf
->overlays_after
== NULL
);
3634 set_buffer_internal (buf
);
3636 bset_enable_multibyte_characters (buf
, Qnil
);
3638 insert_1_both ((char *) read_buf
, nread
, nread
, 0, 0, 0);
3639 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
3640 coding_system
= call2 (Vset_auto_coding_function
,
3641 filename
, make_number (nread
));
3642 set_buffer_internal (prev
);
3644 /* Discard the unwind protect for recovering the
3648 /* Rewind the file for the actual read done later. */
3649 if (lseek (fd
, 0, SEEK_SET
) < 0)
3650 report_file_error ("Setting file position", orig_filename
);
3654 if (NILP (coding_system
))
3656 /* If we have not yet decided a coding system, check
3657 file-coding-system-alist. */
3658 Lisp_Object args
[6];
3660 args
[0] = Qinsert_file_contents
, args
[1] = orig_filename
;
3661 args
[2] = visit
, args
[3] = beg
, args
[4] = end
, args
[5] = replace
;
3662 coding_system
= Ffind_operation_coding_system (6, args
);
3663 if (CONSP (coding_system
))
3664 coding_system
= XCAR (coding_system
);
3668 if (NILP (coding_system
))
3669 coding_system
= Qundecided
;
3671 CHECK_CODING_SYSTEM (coding_system
);
3673 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3674 /* We must suppress all character code conversion except for
3675 end-of-line conversion. */
3676 coding_system
= raw_text_coding_system (coding_system
);
3678 setup_coding_system (coding_system
, &coding
);
3679 /* Ensure we set Vlast_coding_system_used. */
3680 set_coding_system
= 1;
3683 /* If requested, replace the accessible part of the buffer
3684 with the file contents. Avoid replacing text at the
3685 beginning or end of the buffer that matches the file contents;
3686 that preserves markers pointing to the unchanged parts.
3688 Here we implement this feature in an optimized way
3689 for the case where code conversion is NOT needed.
3690 The following if-statement handles the case of conversion
3691 in a less optimal way.
3693 If the code conversion is "automatic" then we try using this
3694 method and hope for the best.
3695 But if we discover the need for conversion, we give up on this method
3696 and let the following if-statement handle the replace job. */
3699 && (NILP (coding_system
)
3700 || ! CODING_REQUIRE_DECODING (&coding
)))
3702 /* same_at_start and same_at_end count bytes,
3703 because file access counts bytes
3704 and BEG and END count bytes. */
3705 ptrdiff_t same_at_start
= BEGV_BYTE
;
3706 ptrdiff_t same_at_end
= ZV_BYTE
;
3708 /* There is still a possibility we will find the need to do code
3709 conversion. If that happens, set this variable to
3710 give up on handling REPLACE in the optimized way. */
3711 bool giveup_match_end
= 0;
3713 if (beg_offset
!= 0)
3715 if (lseek (fd
, beg_offset
, SEEK_SET
) < 0)
3716 report_file_error ("Setting file position", orig_filename
);
3721 /* Count how many chars at the start of the file
3722 match the text at the beginning of the buffer. */
3727 nread
= emacs_read (fd
, read_buf
, sizeof read_buf
);
3729 report_file_error ("Read error", orig_filename
);
3730 else if (nread
== 0)
3733 if (CODING_REQUIRE_DETECTION (&coding
))
3735 coding_system
= detect_coding_system ((unsigned char *) read_buf
,
3738 setup_coding_system (coding_system
, &coding
);
3741 if (CODING_REQUIRE_DECODING (&coding
))
3742 /* We found that the file should be decoded somehow.
3743 Let's give up here. */
3745 giveup_match_end
= 1;
3750 while (bufpos
< nread
&& same_at_start
< ZV_BYTE
3751 && FETCH_BYTE (same_at_start
) == read_buf
[bufpos
])
3752 same_at_start
++, bufpos
++;
3753 /* If we found a discrepancy, stop the scan.
3754 Otherwise loop around and scan the next bufferful. */
3755 if (bufpos
!= nread
)
3759 /* If the file matches the buffer completely,
3760 there's no need to replace anything. */
3761 if (same_at_start
- BEGV_BYTE
== end_offset
- beg_offset
)
3764 clear_unwind_protect (fd_index
);
3766 /* Truncate the buffer to the size of the file. */
3767 del_range_1 (same_at_start
, same_at_end
, 0, 0);
3772 /* Count how many chars at the end of the file
3773 match the text at the end of the buffer. But, if we have
3774 already found that decoding is necessary, don't waste time. */
3775 while (!giveup_match_end
)
3777 int total_read
, nread
, bufpos
, trial
;
3780 /* At what file position are we now scanning? */
3781 curpos
= end_offset
- (ZV_BYTE
- same_at_end
);
3782 /* If the entire file matches the buffer tail, stop the scan. */
3785 /* How much can we scan in the next step? */
3786 trial
= min (curpos
, sizeof read_buf
);
3787 if (lseek (fd
, curpos
- trial
, SEEK_SET
) < 0)
3788 report_file_error ("Setting file position", orig_filename
);
3790 total_read
= nread
= 0;
3791 while (total_read
< trial
)
3793 nread
= emacs_read (fd
, read_buf
+ total_read
, trial
- total_read
);
3795 report_file_error ("Read error", orig_filename
);
3796 else if (nread
== 0)
3798 total_read
+= nread
;
3801 /* Scan this bufferful from the end, comparing with
3802 the Emacs buffer. */
3803 bufpos
= total_read
;
3805 /* Compare with same_at_start to avoid counting some buffer text
3806 as matching both at the file's beginning and at the end. */
3807 while (bufpos
> 0 && same_at_end
> same_at_start
3808 && FETCH_BYTE (same_at_end
- 1) == read_buf
[bufpos
- 1])
3809 same_at_end
--, bufpos
--;
3811 /* If we found a discrepancy, stop the scan.
3812 Otherwise loop around and scan the preceding bufferful. */
3815 /* If this discrepancy is because of code conversion,
3816 we cannot use this method; giveup and try the other. */
3817 if (same_at_end
> same_at_start
3818 && FETCH_BYTE (same_at_end
- 1) >= 0200
3819 && ! NILP (BVAR (current_buffer
, enable_multibyte_characters
))
3820 && (CODING_MAY_REQUIRE_DECODING (&coding
)))
3821 giveup_match_end
= 1;
3830 if (! giveup_match_end
)
3834 /* We win! We can handle REPLACE the optimized way. */
3836 /* Extend the start of non-matching text area to multibyte
3837 character boundary. */
3838 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3839 while (same_at_start
> BEGV_BYTE
3840 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_start
)))
3843 /* Extend the end of non-matching text area to multibyte
3844 character boundary. */
3845 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3846 while (same_at_end
< ZV_BYTE
3847 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_end
)))
3850 /* Don't try to reuse the same piece of text twice. */
3851 overlap
= (same_at_start
- BEGV_BYTE
3853 + (! NILP (end
) ? end_offset
: st
.st_size
) - ZV_BYTE
));
3855 same_at_end
+= overlap
;
3857 /* Arrange to read only the nonmatching middle part of the file. */
3858 beg_offset
+= same_at_start
- BEGV_BYTE
;
3859 end_offset
-= ZV_BYTE
- same_at_end
;
3861 del_range_byte (same_at_start
, same_at_end
, 0);
3862 /* Insert from the file at the proper position. */
3863 temp
= BYTE_TO_CHAR (same_at_start
);
3864 SET_PT_BOTH (temp
, same_at_start
);
3866 /* If display currently starts at beginning of line,
3867 keep it that way. */
3868 if (XBUFFER (XWINDOW (selected_window
)->contents
) == current_buffer
)
3869 XWINDOW (selected_window
)->start_at_line_beg
= !NILP (Fbolp ());
3871 replace_handled
= 1;
3875 /* If requested, replace the accessible part of the buffer
3876 with the file contents. Avoid replacing text at the
3877 beginning or end of the buffer that matches the file contents;
3878 that preserves markers pointing to the unchanged parts.
3880 Here we implement this feature for the case where code conversion
3881 is needed, in a simple way that needs a lot of memory.
3882 The preceding if-statement handles the case of no conversion
3883 in a more optimized way. */
3884 if (!NILP (replace
) && ! replace_handled
&& BEGV
< ZV
)
3886 ptrdiff_t same_at_start
= BEGV_BYTE
;
3887 ptrdiff_t same_at_end
= ZV_BYTE
;
3888 ptrdiff_t same_at_start_charpos
;
3889 ptrdiff_t inserted_chars
;
3892 unsigned char *decoded
;
3895 ptrdiff_t this_count
= SPECPDL_INDEX ();
3897 = ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3898 Lisp_Object conversion_buffer
;
3899 struct gcpro gcpro1
;
3901 conversion_buffer
= code_conversion_save (1, multibyte
);
3903 /* First read the whole file, performing code conversion into
3904 CONVERSION_BUFFER. */
3906 if (lseek (fd
, beg_offset
, SEEK_SET
) < 0)
3907 report_file_error ("Setting file position", orig_filename
);
3909 inserted
= 0; /* Bytes put into CONVERSION_BUFFER so far. */
3910 unprocessed
= 0; /* Bytes not processed in previous loop. */
3912 GCPRO1 (conversion_buffer
);
3915 /* Read at most READ_BUF_SIZE bytes at a time, to allow
3916 quitting while reading a huge file. */
3918 /* Allow quitting out of the actual I/O. */
3921 this = emacs_read (fd
, read_buf
+ unprocessed
,
3922 READ_BUF_SIZE
- unprocessed
);
3928 BUF_TEMP_SET_PT (XBUFFER (conversion_buffer
),
3929 BUF_Z (XBUFFER (conversion_buffer
)));
3930 decode_coding_c_string (&coding
, (unsigned char *) read_buf
,
3931 unprocessed
+ this, conversion_buffer
);
3932 unprocessed
= coding
.carryover_bytes
;
3933 if (coding
.carryover_bytes
> 0)
3934 memcpy (read_buf
, coding
.carryover
, unprocessed
);
3938 report_file_error ("Read error", orig_filename
);
3940 clear_unwind_protect (fd_index
);
3942 if (unprocessed
> 0)
3944 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
3945 decode_coding_c_string (&coding
, (unsigned char *) read_buf
,
3946 unprocessed
, conversion_buffer
);
3947 coding
.mode
&= ~CODING_MODE_LAST_BLOCK
;
3950 coding_system
= CODING_ID_NAME (coding
.id
);
3951 set_coding_system
= 1;
3952 decoded
= BUF_BEG_ADDR (XBUFFER (conversion_buffer
));
3953 inserted
= (BUF_Z_BYTE (XBUFFER (conversion_buffer
))
3954 - BUF_BEG_BYTE (XBUFFER (conversion_buffer
)));
3956 /* Compare the beginning of the converted string with the buffer
3960 while (bufpos
< inserted
&& same_at_start
< same_at_end
3961 && FETCH_BYTE (same_at_start
) == decoded
[bufpos
])
3962 same_at_start
++, bufpos
++;
3964 /* If the file matches the head of buffer completely,
3965 there's no need to replace anything. */
3967 if (bufpos
== inserted
)
3969 /* Truncate the buffer to the size of the file. */
3970 if (same_at_start
!= same_at_end
)
3971 del_range_byte (same_at_start
, same_at_end
, 0);
3974 unbind_to (this_count
, Qnil
);
3978 /* Extend the start of non-matching text area to the previous
3979 multibyte character boundary. */
3980 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3981 while (same_at_start
> BEGV_BYTE
3982 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_start
)))
3985 /* Scan this bufferful from the end, comparing with
3986 the Emacs buffer. */
3989 /* Compare with same_at_start to avoid counting some buffer text
3990 as matching both at the file's beginning and at the end. */
3991 while (bufpos
> 0 && same_at_end
> same_at_start
3992 && FETCH_BYTE (same_at_end
- 1) == decoded
[bufpos
- 1])
3993 same_at_end
--, bufpos
--;
3995 /* Extend the end of non-matching text area to the next
3996 multibyte character boundary. */
3997 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3998 while (same_at_end
< ZV_BYTE
3999 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_end
)))
4002 /* Don't try to reuse the same piece of text twice. */
4003 overlap
= same_at_start
- BEGV_BYTE
- (same_at_end
+ inserted
- ZV_BYTE
);
4005 same_at_end
+= overlap
;
4007 /* If display currently starts at beginning of line,
4008 keep it that way. */
4009 if (XBUFFER (XWINDOW (selected_window
)->contents
) == current_buffer
)
4010 XWINDOW (selected_window
)->start_at_line_beg
= !NILP (Fbolp ());
4012 /* Replace the chars that we need to replace,
4013 and update INSERTED to equal the number of bytes
4014 we are taking from the decoded string. */
4015 inserted
-= (ZV_BYTE
- same_at_end
) + (same_at_start
- BEGV_BYTE
);
4017 if (same_at_end
!= same_at_start
)
4019 del_range_byte (same_at_start
, same_at_end
, 0);
4021 eassert (same_at_start
== GPT_BYTE
);
4022 same_at_start
= GPT_BYTE
;
4026 temp
= BYTE_TO_CHAR (same_at_start
);
4028 /* Insert from the file at the proper position. */
4029 SET_PT_BOTH (temp
, same_at_start
);
4030 same_at_start_charpos
4031 = buf_bytepos_to_charpos (XBUFFER (conversion_buffer
),
4032 same_at_start
- BEGV_BYTE
4033 + BUF_BEG_BYTE (XBUFFER (conversion_buffer
)));
4034 eassert (same_at_start_charpos
== temp
- (BEGV
- BEG
));
4036 = (buf_bytepos_to_charpos (XBUFFER (conversion_buffer
),
4037 same_at_start
+ inserted
- BEGV_BYTE
4038 + BUF_BEG_BYTE (XBUFFER (conversion_buffer
)))
4039 - same_at_start_charpos
);
4040 /* This binding is to avoid ask-user-about-supersession-threat
4041 being called in insert_from_buffer (via in
4042 prepare_to_modify_buffer). */
4043 specbind (intern ("buffer-file-name"), Qnil
);
4044 insert_from_buffer (XBUFFER (conversion_buffer
),
4045 same_at_start_charpos
, inserted_chars
, 0);
4046 /* Set `inserted' to the number of inserted characters. */
4047 inserted
= PT
- temp
;
4048 /* Set point before the inserted characters. */
4049 SET_PT_BOTH (temp
, same_at_start
);
4051 unbind_to (this_count
, Qnil
);
4057 total
= end_offset
- beg_offset
;
4059 /* For a special file, all we can do is guess. */
4060 total
= READ_BUF_SIZE
;
4062 if (NILP (visit
) && total
> 0)
4064 #ifdef CLASH_DETECTION
4065 if (!NILP (BVAR (current_buffer
, file_truename
))
4066 /* Make binding buffer-file-name to nil effective. */
4067 && !NILP (BVAR (current_buffer
, filename
))
4068 && SAVE_MODIFF
>= MODIFF
)
4070 #endif /* CLASH_DETECTION */
4071 prepare_to_modify_buffer (GPT
, GPT
, NULL
);
4074 move_gap_both (PT
, PT_BYTE
);
4075 if (GAP_SIZE
< total
)
4076 make_gap (total
- GAP_SIZE
);
4078 if (beg_offset
!= 0 || !NILP (replace
))
4080 if (lseek (fd
, beg_offset
, SEEK_SET
) < 0)
4081 report_file_error ("Setting file position", orig_filename
);
4084 /* In the following loop, HOW_MUCH contains the total bytes read so
4085 far for a regular file, and not changed for a special file. But,
4086 before exiting the loop, it is set to a negative value if I/O
4090 /* Total bytes inserted. */
4093 /* Here, we don't do code conversion in the loop. It is done by
4094 decode_coding_gap after all data are read into the buffer. */
4096 ptrdiff_t gap_size
= GAP_SIZE
;
4098 while (how_much
< total
)
4100 /* try is reserved in some compilers (Microsoft C) */
4101 ptrdiff_t trytry
= min (total
- how_much
, READ_BUF_SIZE
);
4108 /* Maybe make more room. */
4109 if (gap_size
< trytry
)
4111 make_gap (trytry
- gap_size
);
4112 gap_size
= GAP_SIZE
- inserted
;
4115 /* Read from the file, capturing `quit'. When an
4116 error occurs, end the loop, and arrange for a quit
4117 to be signaled after decoding the text we read. */
4118 nbytes
= internal_condition_case_1
4120 make_save_int_int_int (fd
, inserted
, trytry
),
4121 Qerror
, read_non_regular_quit
);
4129 this = XINT (nbytes
);
4133 /* Allow quitting out of the actual I/O. We don't make text
4134 part of the buffer until all the reading is done, so a C-g
4135 here doesn't do any harm. */
4138 this = emacs_read (fd
,
4139 ((char *) BEG_ADDR
+ PT_BYTE
- BEG_BYTE
4153 /* For a regular file, where TOTAL is the real size,
4154 count HOW_MUCH to compare with it.
4155 For a special file, where TOTAL is just a buffer size,
4156 so don't bother counting in HOW_MUCH.
4157 (INSERTED is where we count the number of characters inserted.) */
4164 /* Now we have either read all the file data into the gap,
4165 or stop reading on I/O error or quit. If nothing was
4166 read, undo marking the buffer modified. */
4170 #ifdef CLASH_DETECTION
4172 unlock_file (BVAR (current_buffer
, file_truename
));
4174 Vdeactivate_mark
= old_Vdeactivate_mark
;
4177 Vdeactivate_mark
= Qt
;
4180 clear_unwind_protect (fd_index
);
4183 report_file_error ("Read error", orig_filename
);
4185 /* Make the text read part of the buffer. */
4186 GAP_SIZE
-= inserted
;
4188 GPT_BYTE
+= inserted
;
4190 ZV_BYTE
+= inserted
;
4195 /* Put an anchor to ensure multi-byte form ends at gap. */
4200 if (NILP (coding_system
))
4202 /* The coding system is not yet decided. Decide it by an
4203 optimized method for handling `coding:' tag.
4205 Note that we can get here only if the buffer was empty
4206 before the insertion. */
4208 if (!NILP (Vcoding_system_for_read
))
4209 coding_system
= Vcoding_system_for_read
;
4212 /* Since we are sure that the current buffer was empty
4213 before the insertion, we can toggle
4214 enable-multibyte-characters directly here without taking
4215 care of marker adjustment. By this way, we can run Lisp
4216 program safely before decoding the inserted text. */
4217 Lisp_Object unwind_data
;
4218 ptrdiff_t count1
= SPECPDL_INDEX ();
4220 unwind_data
= Fcons (BVAR (current_buffer
, enable_multibyte_characters
),
4221 Fcons (BVAR (current_buffer
, undo_list
),
4222 Fcurrent_buffer ()));
4223 bset_enable_multibyte_characters (current_buffer
, Qnil
);
4224 bset_undo_list (current_buffer
, Qt
);
4225 record_unwind_protect (decide_coding_unwind
, unwind_data
);
4227 if (inserted
> 0 && ! NILP (Vset_auto_coding_function
))
4229 coding_system
= call2 (Vset_auto_coding_function
,
4230 filename
, make_number (inserted
));
4233 if (NILP (coding_system
))
4235 /* If the coding system is not yet decided, check
4236 file-coding-system-alist. */
4237 Lisp_Object args
[6];
4239 args
[0] = Qinsert_file_contents
, args
[1] = orig_filename
;
4240 args
[2] = visit
, args
[3] = beg
, args
[4] = end
, args
[5] = Qnil
;
4241 coding_system
= Ffind_operation_coding_system (6, args
);
4242 if (CONSP (coding_system
))
4243 coding_system
= XCAR (coding_system
);
4245 unbind_to (count1
, Qnil
);
4246 inserted
= Z_BYTE
- BEG_BYTE
;
4249 if (NILP (coding_system
))
4250 coding_system
= Qundecided
;
4252 CHECK_CODING_SYSTEM (coding_system
);
4254 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
4255 /* We must suppress all character code conversion except for
4256 end-of-line conversion. */
4257 coding_system
= raw_text_coding_system (coding_system
);
4258 setup_coding_system (coding_system
, &coding
);
4259 /* Ensure we set Vlast_coding_system_used. */
4260 set_coding_system
= 1;
4265 /* When we visit a file by raw-text, we change the buffer to
4267 if (CODING_FOR_UNIBYTE (&coding
)
4268 /* Can't do this if part of the buffer might be preserved. */
4270 /* Visiting a file with these coding system makes the buffer
4272 bset_enable_multibyte_characters (current_buffer
, Qnil
);
4275 coding
.dst_multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
4276 if (CODING_MAY_REQUIRE_DECODING (&coding
)
4277 && (inserted
> 0 || CODING_REQUIRE_FLUSHING (&coding
)))
4279 move_gap_both (PT
, PT_BYTE
);
4280 GAP_SIZE
+= inserted
;
4281 ZV_BYTE
-= inserted
;
4285 decode_coding_gap (&coding
, inserted
, inserted
);
4286 inserted
= coding
.produced_char
;
4287 coding_system
= CODING_ID_NAME (coding
.id
);
4289 else if (inserted
> 0)
4290 adjust_after_insert (PT
, PT_BYTE
, PT
+ inserted
, PT_BYTE
+ inserted
,
4293 /* Call after-change hooks for the inserted text, aside from the case
4294 of normal visiting (not with REPLACE), which is done in a new buffer
4295 "before" the buffer is changed. */
4296 if (inserted
> 0 && total
> 0
4297 && (NILP (visit
) || !NILP (replace
)))
4299 signal_after_change (PT
, 0, inserted
);
4300 update_compositions (PT
, PT
, CHECK_BORDER
);
4303 /* Now INSERTED is measured in characters. */
4309 if (empty_undo_list_p
)
4310 bset_undo_list (current_buffer
, Qnil
);
4314 current_buffer
->modtime
= mtime
;
4315 current_buffer
->modtime_size
= st
.st_size
;
4316 bset_filename (current_buffer
, orig_filename
);
4319 SAVE_MODIFF
= MODIFF
;
4320 BUF_AUTOSAVE_MODIFF (current_buffer
) = MODIFF
;
4321 XSETFASTINT (BVAR (current_buffer
, save_length
), Z
- BEG
);
4322 #ifdef CLASH_DETECTION
4325 if (!NILP (BVAR (current_buffer
, file_truename
)))
4326 unlock_file (BVAR (current_buffer
, file_truename
));
4327 unlock_file (filename
);
4329 #endif /* CLASH_DETECTION */
4331 xsignal2 (Qfile_error
,
4332 build_string ("not a regular file"), orig_filename
);
4335 if (set_coding_system
)
4336 Vlast_coding_system_used
= coding_system
;
4338 if (! NILP (Ffboundp (Qafter_insert_file_set_coding
)))
4340 insval
= call2 (Qafter_insert_file_set_coding
, make_number (inserted
),
4342 if (! NILP (insval
))
4344 if (! RANGED_INTEGERP (0, insval
, ZV
- PT
))
4345 wrong_type_argument (intern ("inserted-chars"), insval
);
4346 inserted
= XFASTINT (insval
);
4350 /* Decode file format. */
4353 /* Don't run point motion or modification hooks when decoding. */
4354 ptrdiff_t count1
= SPECPDL_INDEX ();
4355 ptrdiff_t old_inserted
= inserted
;
4356 specbind (Qinhibit_point_motion_hooks
, Qt
);
4357 specbind (Qinhibit_modification_hooks
, Qt
);
4359 /* Save old undo list and don't record undo for decoding. */
4360 old_undo
= BVAR (current_buffer
, undo_list
);
4361 bset_undo_list (current_buffer
, Qt
);
4365 insval
= call3 (Qformat_decode
,
4366 Qnil
, make_number (inserted
), visit
);
4367 if (! RANGED_INTEGERP (0, insval
, ZV
- PT
))
4368 wrong_type_argument (intern ("inserted-chars"), insval
);
4369 inserted
= XFASTINT (insval
);
4373 /* If REPLACE is non-nil and we succeeded in not replacing the
4374 beginning or end of the buffer text with the file's contents,
4375 call format-decode with `point' positioned at the beginning
4376 of the buffer and `inserted' equaling the number of
4377 characters in the buffer. Otherwise, format-decode might
4378 fail to correctly analyze the beginning or end of the buffer.
4379 Hence we temporarily save `point' and `inserted' here and
4380 restore `point' iff format-decode did not insert or delete
4381 any text. Otherwise we leave `point' at point-min. */
4382 ptrdiff_t opoint
= PT
;
4383 ptrdiff_t opoint_byte
= PT_BYTE
;
4384 ptrdiff_t oinserted
= ZV
- BEGV
;
4385 EMACS_INT ochars_modiff
= CHARS_MODIFF
;
4387 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
4388 insval
= call3 (Qformat_decode
,
4389 Qnil
, make_number (oinserted
), visit
);
4390 if (! RANGED_INTEGERP (0, insval
, ZV
- PT
))
4391 wrong_type_argument (intern ("inserted-chars"), insval
);
4392 if (ochars_modiff
== CHARS_MODIFF
)
4393 /* format_decode didn't modify buffer's characters => move
4394 point back to position before inserted text and leave
4395 value of inserted alone. */
4396 SET_PT_BOTH (opoint
, opoint_byte
);
4398 /* format_decode modified buffer's characters => consider
4399 entire buffer changed and leave point at point-min. */
4400 inserted
= XFASTINT (insval
);
4403 /* For consistency with format-decode call these now iff inserted > 0
4404 (martin 2007-06-28). */
4405 p
= Vafter_insert_file_functions
;
4410 insval
= call1 (XCAR (p
), make_number (inserted
));
4413 if (! RANGED_INTEGERP (0, insval
, ZV
- PT
))
4414 wrong_type_argument (intern ("inserted-chars"), insval
);
4415 inserted
= XFASTINT (insval
);
4420 /* For the rationale of this see the comment on
4421 format-decode above. */
4422 ptrdiff_t opoint
= PT
;
4423 ptrdiff_t opoint_byte
= PT_BYTE
;
4424 ptrdiff_t oinserted
= ZV
- BEGV
;
4425 EMACS_INT ochars_modiff
= CHARS_MODIFF
;
4427 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
4428 insval
= call1 (XCAR (p
), make_number (oinserted
));
4431 if (! RANGED_INTEGERP (0, insval
, ZV
- PT
))
4432 wrong_type_argument (intern ("inserted-chars"), insval
);
4433 if (ochars_modiff
== CHARS_MODIFF
)
4434 /* after_insert_file_functions didn't modify
4435 buffer's characters => move point back to
4436 position before inserted text and leave value of
4438 SET_PT_BOTH (opoint
, opoint_byte
);
4440 /* after_insert_file_functions did modify buffer's
4441 characters => consider entire buffer changed and
4442 leave point at point-min. */
4443 inserted
= XFASTINT (insval
);
4451 if (!empty_undo_list_p
)
4453 bset_undo_list (current_buffer
, old_undo
);
4454 if (CONSP (old_undo
) && inserted
!= old_inserted
)
4456 /* Adjust the last undo record for the size change during
4457 the format conversion. */
4458 Lisp_Object tem
= XCAR (old_undo
);
4459 if (CONSP (tem
) && INTEGERP (XCAR (tem
))
4460 && INTEGERP (XCDR (tem
))
4461 && XFASTINT (XCDR (tem
)) == PT
+ old_inserted
)
4462 XSETCDR (tem
, make_number (PT
+ inserted
));
4466 /* If undo_list was Qt before, keep it that way.
4467 Otherwise start with an empty undo_list. */
4468 bset_undo_list (current_buffer
, EQ (old_undo
, Qt
) ? Qt
: Qnil
);
4470 unbind_to (count1
, Qnil
);
4474 && current_buffer
->modtime
.tv_nsec
== NONEXISTENT_MODTIME_NSECS
)
4476 /* If visiting nonexistent file, return nil. */
4477 report_file_errno ("Opening input file", orig_filename
, save_errno
);
4480 /* We made a lot of deletions and insertions above, so invalidate
4481 the newline cache for the entire region of the inserted
4483 if (current_buffer
->newline_cache
)
4484 invalidate_region_cache (current_buffer
,
4485 current_buffer
->newline_cache
,
4486 PT
- BEG
, Z
- PT
- inserted
);
4489 Fsignal (Qquit
, Qnil
);
4491 /* Retval needs to be dealt with in all cases consistently. */
4493 val
= list2 (orig_filename
, make_number (inserted
));
4495 RETURN_UNGCPRO (unbind_to (count
, val
));
4498 static Lisp_Object
build_annotations (Lisp_Object
, Lisp_Object
);
4501 build_annotations_unwind (Lisp_Object arg
)
4503 Vwrite_region_annotation_buffers
= arg
;
4506 /* Decide the coding-system to encode the data with. */
4508 DEFUN ("choose-write-coding-system", Fchoose_write_coding_system
,
4509 Schoose_write_coding_system
, 3, 6, 0,
4510 doc
: /* Choose the coding system for writing a file.
4511 Arguments are as for `write-region'.
4512 This function is for internal use only. It may prompt the user. */ )
4513 (Lisp_Object start
, Lisp_Object end
, Lisp_Object filename
,
4514 Lisp_Object append
, Lisp_Object visit
, Lisp_Object lockname
)
4517 Lisp_Object eol_parent
= Qnil
;
4519 /* Mimic write-region behavior. */
4522 XSETFASTINT (start
, BEGV
);
4523 XSETFASTINT (end
, ZV
);
4527 && NILP (Fstring_equal (BVAR (current_buffer
, filename
),
4528 BVAR (current_buffer
, auto_save_file_name
))))
4533 else if (!NILP (Vcoding_system_for_write
))
4535 val
= Vcoding_system_for_write
;
4536 if (coding_system_require_warning
4537 && !NILP (Ffboundp (Vselect_safe_coding_system_function
)))
4538 /* Confirm that VAL can surely encode the current region. */
4539 val
= call5 (Vselect_safe_coding_system_function
,
4540 start
, end
, list2 (Qt
, val
),
4545 /* If the variable `buffer-file-coding-system' is set locally,
4546 it means that the file was read with some kind of code
4547 conversion or the variable is explicitly set by users. We
4548 had better write it out with the same coding system even if
4549 `enable-multibyte-characters' is nil.
4551 If it is not set locally, we anyway have to convert EOL
4552 format if the default value of `buffer-file-coding-system'
4553 tells that it is not Unix-like (LF only) format. */
4554 bool using_default_coding
= 0;
4555 bool force_raw_text
= 0;
4557 val
= BVAR (current_buffer
, buffer_file_coding_system
);
4559 || NILP (Flocal_variable_p (Qbuffer_file_coding_system
, Qnil
)))
4562 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
4568 /* Check file-coding-system-alist. */
4569 Lisp_Object args
[7], coding_systems
;
4571 args
[0] = Qwrite_region
; args
[1] = start
; args
[2] = end
;
4572 args
[3] = filename
; args
[4] = append
; args
[5] = visit
;
4574 coding_systems
= Ffind_operation_coding_system (7, args
);
4575 if (CONSP (coding_systems
) && !NILP (XCDR (coding_systems
)))
4576 val
= XCDR (coding_systems
);
4581 /* If we still have not decided a coding system, use the
4582 default value of buffer-file-coding-system. */
4583 val
= BVAR (current_buffer
, buffer_file_coding_system
);
4584 using_default_coding
= 1;
4587 if (! NILP (val
) && ! force_raw_text
)
4589 Lisp_Object spec
, attrs
;
4591 CHECK_CODING_SYSTEM_GET_SPEC (val
, spec
);
4592 attrs
= AREF (spec
, 0);
4593 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
4598 && !NILP (Ffboundp (Vselect_safe_coding_system_function
)))
4599 /* Confirm that VAL can surely encode the current region. */
4600 val
= call5 (Vselect_safe_coding_system_function
,
4601 start
, end
, val
, Qnil
, filename
);
4603 /* If the decided coding-system doesn't specify end-of-line
4604 format, we use that of
4605 `default-buffer-file-coding-system'. */
4606 if (! using_default_coding
4607 && ! NILP (BVAR (&buffer_defaults
, buffer_file_coding_system
)))
4608 val
= (coding_inherit_eol_type
4609 (val
, BVAR (&buffer_defaults
, buffer_file_coding_system
)));
4611 /* If we decide not to encode text, use `raw-text' or one of its
4614 val
= raw_text_coding_system (val
);
4617 val
= coding_inherit_eol_type (val
, eol_parent
);
4621 DEFUN ("write-region", Fwrite_region
, Swrite_region
, 3, 7,
4622 "r\nFWrite region to file: \ni\ni\ni\np",
4623 doc
: /* Write current region into specified file.
4624 When called from a program, requires three arguments:
4625 START, END and FILENAME. START and END are normally buffer positions
4626 specifying the part of the buffer to write.
4627 If START is nil, that means to use the entire buffer contents.
4628 If START is a string, then output that string to the file
4629 instead of any buffer contents; END is ignored.
4631 Optional fourth argument APPEND if non-nil means
4632 append to existing file contents (if any). If it is a number,
4633 seek to that offset in the file before writing.
4634 Optional fifth argument VISIT, if t or a string, means
4635 set the last-save-file-modtime of buffer to this file's modtime
4636 and mark buffer not modified.
4637 If VISIT is a string, it is a second file name;
4638 the output goes to FILENAME, but the buffer is marked as visiting VISIT.
4639 VISIT is also the file name to lock and unlock for clash detection.
4640 If VISIT is neither t nor nil nor a string,
4641 that means do not display the \"Wrote file\" message.
4642 The optional sixth arg LOCKNAME, if non-nil, specifies the name to
4643 use for locking and unlocking, overriding FILENAME and VISIT.
4644 The optional seventh arg MUSTBENEW, if non-nil, insists on a check
4645 for an existing file with the same name. If MUSTBENEW is `excl',
4646 that means to get an error if the file already exists; never overwrite.
4647 If MUSTBENEW is neither nil nor `excl', that means ask for
4648 confirmation before overwriting, but do go ahead and overwrite the file
4649 if the user confirms.
4651 This does code conversion according to the value of
4652 `coding-system-for-write', `buffer-file-coding-system', or
4653 `file-coding-system-alist', and sets the variable
4654 `last-coding-system-used' to the coding system actually used.
4656 This calls `write-region-annotate-functions' at the start, and
4657 `write-region-post-annotation-function' at the end. */)
4658 (Lisp_Object start
, Lisp_Object end
, Lisp_Object filename
, Lisp_Object append
,
4659 Lisp_Object visit
, Lisp_Object lockname
, Lisp_Object mustbenew
)
4661 return write_region (start
, end
, filename
, append
, visit
, lockname
, mustbenew
,
4665 /* Like Fwrite_region, except that if DESC is nonnegative, it is a file
4666 descriptor for FILENAME, so do not open or close FILENAME. */
4669 write_region (Lisp_Object start
, Lisp_Object end
, Lisp_Object filename
,
4670 Lisp_Object append
, Lisp_Object visit
, Lisp_Object lockname
,
4671 Lisp_Object mustbenew
, int desc
)
4675 off_t offset
IF_LINT (= 0);
4676 bool open_and_close_file
= desc
< 0;
4681 struct timespec modtime
;
4682 ptrdiff_t count
= SPECPDL_INDEX ();
4683 ptrdiff_t count1
IF_LINT (= 0);
4684 Lisp_Object handler
;
4685 Lisp_Object visit_file
;
4686 Lisp_Object annotations
;
4687 Lisp_Object encoded_filename
;
4688 bool visiting
= (EQ (visit
, Qt
) || STRINGP (visit
));
4689 bool quietly
= !NILP (visit
);
4690 bool file_locked
= 0;
4691 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
4692 struct buffer
*given_buffer
;
4693 struct coding_system coding
;
4695 if (current_buffer
->base_buffer
&& visiting
)
4696 error ("Cannot do file visiting in an indirect buffer");
4698 if (!NILP (start
) && !STRINGP (start
))
4699 validate_region (&start
, &end
);
4702 GCPRO5 (start
, filename
, visit
, visit_file
, lockname
);
4704 filename
= Fexpand_file_name (filename
, Qnil
);
4706 if (!NILP (mustbenew
) && !EQ (mustbenew
, Qexcl
))
4707 barf_or_query_if_file_exists (filename
, "overwrite", 1, 0, 1);
4709 if (STRINGP (visit
))
4710 visit_file
= Fexpand_file_name (visit
, Qnil
);
4712 visit_file
= filename
;
4714 if (NILP (lockname
))
4715 lockname
= visit_file
;
4719 /* If the file name has special constructs in it,
4720 call the corresponding file handler. */
4721 handler
= Ffind_file_name_handler (filename
, Qwrite_region
);
4722 /* If FILENAME has no handler, see if VISIT has one. */
4723 if (NILP (handler
) && STRINGP (visit
))
4724 handler
= Ffind_file_name_handler (visit
, Qwrite_region
);
4726 if (!NILP (handler
))
4729 val
= call6 (handler
, Qwrite_region
, start
, end
,
4730 filename
, append
, visit
);
4734 SAVE_MODIFF
= MODIFF
;
4735 XSETFASTINT (BVAR (current_buffer
, save_length
), Z
- BEG
);
4736 bset_filename (current_buffer
, visit_file
);
4742 record_unwind_protect (save_restriction_restore
, save_restriction_save ());
4744 /* Special kludge to simplify auto-saving. */
4747 /* Do it later, so write-region-annotate-function can work differently
4748 if we save "the buffer" vs "a region".
4749 This is useful in tar-mode. --Stef
4750 XSETFASTINT (start, BEG);
4751 XSETFASTINT (end, Z); */
4755 record_unwind_protect (build_annotations_unwind
,
4756 Vwrite_region_annotation_buffers
);
4757 Vwrite_region_annotation_buffers
= list1 (Fcurrent_buffer ());
4759 given_buffer
= current_buffer
;
4761 if (!STRINGP (start
))
4763 annotations
= build_annotations (start
, end
);
4765 if (current_buffer
!= given_buffer
)
4767 XSETFASTINT (start
, BEGV
);
4768 XSETFASTINT (end
, ZV
);
4774 XSETFASTINT (start
, BEGV
);
4775 XSETFASTINT (end
, ZV
);
4780 GCPRO5 (start
, filename
, annotations
, visit_file
, lockname
);
4782 /* Decide the coding-system to encode the data with.
4783 We used to make this choice before calling build_annotations, but that
4784 leads to problems when a write-annotate-function takes care of
4785 unsavable chars (as was the case with X-Symbol). */
4786 Vlast_coding_system_used
=
4787 Fchoose_write_coding_system (start
, end
, filename
,
4788 append
, visit
, lockname
);
4790 setup_coding_system (Vlast_coding_system_used
, &coding
);
4792 if (!STRINGP (start
) && !NILP (BVAR (current_buffer
, selective_display
)))
4793 coding
.mode
|= CODING_MODE_SELECTIVE_DISPLAY
;
4795 #ifdef CLASH_DETECTION
4796 if (open_and_close_file
&& !auto_saving
)
4798 lock_file (lockname
);
4801 #endif /* CLASH_DETECTION */
4803 encoded_filename
= ENCODE_FILE (filename
);
4804 fn
= SSDATA (encoded_filename
);
4805 open_flags
= O_WRONLY
| O_BINARY
| O_CREAT
;
4806 open_flags
|= EQ (mustbenew
, Qexcl
) ? O_EXCL
: !NILP (append
) ? 0 : O_TRUNC
;
4807 if (NUMBERP (append
))
4808 offset
= file_offset (append
);
4809 else if (!NILP (append
))
4810 open_flags
|= O_APPEND
;
4812 mode
= S_IREAD
| S_IWRITE
;
4814 mode
= auto_saving
? auto_save_mode_bits
: 0666;
4817 if (open_and_close_file
)
4819 desc
= emacs_open (fn
, open_flags
, mode
);
4822 int open_errno
= errno
;
4823 #ifdef CLASH_DETECTION
4825 unlock_file (lockname
);
4826 #endif /* CLASH_DETECTION */
4828 report_file_errno ("Opening output file", filename
, open_errno
);
4831 count1
= SPECPDL_INDEX ();
4832 record_unwind_protect_int (close_file_unwind
, desc
);
4835 if (NUMBERP (append
))
4837 off_t ret
= lseek (desc
, offset
, SEEK_SET
);
4840 int lseek_errno
= errno
;
4841 #ifdef CLASH_DETECTION
4843 unlock_file (lockname
);
4844 #endif /* CLASH_DETECTION */
4846 report_file_errno ("Lseek error", filename
, lseek_errno
);
4854 if (STRINGP (start
))
4855 ok
= a_write (desc
, start
, 0, SCHARS (start
), &annotations
, &coding
);
4856 else if (XINT (start
) != XINT (end
))
4857 ok
= a_write (desc
, Qnil
, XINT (start
), XINT (end
) - XINT (start
),
4858 &annotations
, &coding
);
4861 /* If file was empty, still need to write the annotations. */
4862 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
4863 ok
= a_write (desc
, Qnil
, XINT (end
), 0, &annotations
, &coding
);
4867 if (ok
&& CODING_REQUIRE_FLUSHING (&coding
)
4868 && !(coding
.mode
& CODING_MODE_LAST_BLOCK
))
4870 /* We have to flush out a data. */
4871 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
4872 ok
= e_write (desc
, Qnil
, 1, 1, &coding
);
4878 /* fsync is not crucial for temporary files. Nor for auto-save
4879 files, since they might lose some work anyway. */
4880 if (open_and_close_file
&& !auto_saving
&& !write_region_inhibit_fsync
)
4882 /* Transfer data and metadata to disk, retrying if interrupted.
4883 fsync can report a write failure here, e.g., due to disk full
4884 under NFS. But ignore EINVAL, which means fsync is not
4885 supported on this file. */
4886 while (fsync (desc
) != 0)
4889 if (errno
!= EINVAL
)
4890 ok
= 0, save_errno
= errno
;
4895 modtime
= invalid_timespec ();
4898 if (fstat (desc
, &st
) == 0)
4899 modtime
= get_stat_mtime (&st
);
4901 ok
= 0, save_errno
= errno
;
4904 if (open_and_close_file
)
4906 /* NFS can report a write failure now. */
4907 if (emacs_close (desc
) < 0)
4908 ok
= 0, save_errno
= errno
;
4910 /* Discard the unwind protect for close_file_unwind. */
4911 specpdl_ptr
= specpdl
+ count1
;
4914 /* Some file systems have a bug where st_mtime is not updated
4915 properly after a write. For example, CIFS might not see the
4916 st_mtime change until after the file is opened again.
4918 Attempt to detect this file system bug, and update MODTIME to the
4919 newer st_mtime if the bug appears to be present. This introduces
4920 a race condition, so to avoid most instances of the race condition
4921 on non-buggy file systems, skip this check if the most recently
4922 encountered non-buggy file system was the current file system.
4924 A race condition can occur if some other process modifies the
4925 file between the fstat above and the fstat below, but the race is
4926 unlikely and a similar race between the last write and the fstat
4927 above cannot possibly be closed anyway. */
4929 if (timespec_valid_p (modtime
)
4930 && ! (valid_timestamp_file_system
&& st
.st_dev
== timestamp_file_system
))
4932 int desc1
= emacs_open (fn
, O_WRONLY
| O_BINARY
, 0);
4936 if (fstat (desc1
, &st1
) == 0
4937 && st
.st_dev
== st1
.st_dev
&& st
.st_ino
== st1
.st_ino
)
4939 /* Use the heuristic if it appears to be valid. With neither
4940 O_EXCL nor O_TRUNC, if Emacs happened to write nothing to the
4941 file, the time stamp won't change. Also, some non-POSIX
4942 systems don't update an empty file's time stamp when
4943 truncating it. Finally, file systems with 100 ns or worse
4944 resolution sometimes seem to have bugs: on a system with ns
4945 resolution, checking ns % 100 incorrectly avoids the heuristic
4946 1% of the time, but the problem should be temporary as we will
4947 try again on the next time stamp. */
4949 = ((open_flags
& (O_EXCL
| O_TRUNC
)) != 0
4951 && modtime
.tv_nsec
% 100 != 0);
4953 struct timespec modtime1
= get_stat_mtime (&st1
);
4955 && timespec_cmp (modtime
, modtime1
) == 0
4956 && st
.st_size
== st1
.st_size
)
4958 timestamp_file_system
= st
.st_dev
;
4959 valid_timestamp_file_system
= 1;
4963 st
.st_size
= st1
.st_size
;
4967 emacs_close (desc1
);
4971 /* Call write-region-post-annotation-function. */
4972 while (CONSP (Vwrite_region_annotation_buffers
))
4974 Lisp_Object buf
= XCAR (Vwrite_region_annotation_buffers
);
4975 if (!NILP (Fbuffer_live_p (buf
)))
4978 if (FUNCTIONP (Vwrite_region_post_annotation_function
))
4979 call0 (Vwrite_region_post_annotation_function
);
4981 Vwrite_region_annotation_buffers
4982 = XCDR (Vwrite_region_annotation_buffers
);
4985 unbind_to (count
, Qnil
);
4987 #ifdef CLASH_DETECTION
4989 unlock_file (lockname
);
4990 #endif /* CLASH_DETECTION */
4992 /* Do this before reporting IO error
4993 to avoid a "file has changed on disk" warning on
4994 next attempt to save. */
4995 if (timespec_valid_p (modtime
))
4997 current_buffer
->modtime
= modtime
;
4998 current_buffer
->modtime_size
= st
.st_size
;
5002 report_file_errno ("Write error", filename
, save_errno
);
5006 SAVE_MODIFF
= MODIFF
;
5007 XSETFASTINT (BVAR (current_buffer
, save_length
), Z
- BEG
);
5008 bset_filename (current_buffer
, visit_file
);
5009 update_mode_lines
= 14;
5014 && ! NILP (Fstring_equal (BVAR (current_buffer
, filename
),
5015 BVAR (current_buffer
, auto_save_file_name
))))
5016 SAVE_MODIFF
= MODIFF
;
5022 message_with_string ((NUMBERP (append
)
5032 DEFUN ("car-less-than-car", Fcar_less_than_car
, Scar_less_than_car
, 2, 2, 0,
5033 doc
: /* Return t if (car A) is numerically less than (car B). */)
5034 (Lisp_Object a
, Lisp_Object b
)
5036 Lisp_Object args
[2] = { Fcar (a
), Fcar (b
), };
5037 return Flss (2, args
);
5040 /* Build the complete list of annotations appropriate for writing out
5041 the text between START and END, by calling all the functions in
5042 write-region-annotate-functions and merging the lists they return.
5043 If one of these functions switches to a different buffer, we assume
5044 that buffer contains altered text. Therefore, the caller must
5045 make sure to restore the current buffer in all cases,
5046 as save-excursion would do. */
5049 build_annotations (Lisp_Object start
, Lisp_Object end
)
5051 Lisp_Object annotations
;
5053 struct gcpro gcpro1
, gcpro2
;
5054 Lisp_Object original_buffer
;
5056 bool used_global
= 0;
5058 XSETBUFFER (original_buffer
, current_buffer
);
5061 p
= Vwrite_region_annotate_functions
;
5062 GCPRO2 (annotations
, p
);
5065 struct buffer
*given_buffer
= current_buffer
;
5066 if (EQ (Qt
, XCAR (p
)) && !used_global
)
5067 { /* Use the global value of the hook. */
5070 arg
[0] = Fdefault_value (Qwrite_region_annotate_functions
);
5072 p
= Fappend (2, arg
);
5075 Vwrite_region_annotations_so_far
= annotations
;
5076 res
= call2 (XCAR (p
), start
, end
);
5077 /* If the function makes a different buffer current,
5078 assume that means this buffer contains altered text to be output.
5079 Reset START and END from the buffer bounds
5080 and discard all previous annotations because they should have
5081 been dealt with by this function. */
5082 if (current_buffer
!= given_buffer
)
5084 Vwrite_region_annotation_buffers
5085 = Fcons (Fcurrent_buffer (),
5086 Vwrite_region_annotation_buffers
);
5087 XSETFASTINT (start
, BEGV
);
5088 XSETFASTINT (end
, ZV
);
5091 Flength (res
); /* Check basic validity of return value */
5092 annotations
= merge (annotations
, res
, Qcar_less_than_car
);
5096 /* Now do the same for annotation functions implied by the file-format */
5097 if (auto_saving
&& (!EQ (BVAR (current_buffer
, auto_save_file_format
), Qt
)))
5098 p
= BVAR (current_buffer
, auto_save_file_format
);
5100 p
= BVAR (current_buffer
, file_format
);
5101 for (i
= 0; CONSP (p
); p
= XCDR (p
), ++i
)
5103 struct buffer
*given_buffer
= current_buffer
;
5105 Vwrite_region_annotations_so_far
= annotations
;
5107 /* Value is either a list of annotations or nil if the function
5108 has written annotations to a temporary buffer, which is now
5110 res
= call5 (Qformat_annotate_function
, XCAR (p
), start
, end
,
5111 original_buffer
, make_number (i
));
5112 if (current_buffer
!= given_buffer
)
5114 XSETFASTINT (start
, BEGV
);
5115 XSETFASTINT (end
, ZV
);
5120 annotations
= merge (annotations
, res
, Qcar_less_than_car
);
5128 /* Write to descriptor DESC the NCHARS chars starting at POS of STRING.
5129 If STRING is nil, POS is the character position in the current buffer.
5130 Intersperse with them the annotations from *ANNOT
5131 which fall within the range of POS to POS + NCHARS,
5132 each at its appropriate position.
5134 We modify *ANNOT by discarding elements as we use them up.
5136 Return true if successful. */
5139 a_write (int desc
, Lisp_Object string
, ptrdiff_t pos
,
5140 ptrdiff_t nchars
, Lisp_Object
*annot
,
5141 struct coding_system
*coding
)
5145 ptrdiff_t lastpos
= pos
+ nchars
;
5147 while (NILP (*annot
) || CONSP (*annot
))
5149 tem
= Fcar_safe (Fcar (*annot
));
5152 nextpos
= XFASTINT (tem
);
5154 /* If there are no more annotations in this range,
5155 output the rest of the range all at once. */
5156 if (! (nextpos
>= pos
&& nextpos
<= lastpos
))
5157 return e_write (desc
, string
, pos
, lastpos
, coding
);
5159 /* Output buffer text up to the next annotation's position. */
5162 if (!e_write (desc
, string
, pos
, nextpos
, coding
))
5166 /* Output the annotation. */
5167 tem
= Fcdr (Fcar (*annot
));
5170 if (!e_write (desc
, tem
, 0, SCHARS (tem
), coding
))
5173 *annot
= Fcdr (*annot
);
5178 /* Maximum number of characters that the next
5179 function encodes per one loop iteration. */
5181 enum { E_WRITE_MAX
= 8 * 1024 * 1024 };
5183 /* Write text in the range START and END into descriptor DESC,
5184 encoding them with coding system CODING. If STRING is nil, START
5185 and END are character positions of the current buffer, else they
5186 are indexes to the string STRING. Return true if successful. */
5189 e_write (int desc
, Lisp_Object string
, ptrdiff_t start
, ptrdiff_t end
,
5190 struct coding_system
*coding
)
5192 if (STRINGP (string
))
5195 end
= SCHARS (string
);
5198 /* We used to have a code for handling selective display here. But,
5199 now it is handled within encode_coding. */
5203 if (STRINGP (string
))
5205 coding
->src_multibyte
= SCHARS (string
) < SBYTES (string
);
5206 if (CODING_REQUIRE_ENCODING (coding
))
5208 ptrdiff_t nchars
= min (end
- start
, E_WRITE_MAX
);
5210 /* Avoid creating huge Lisp string in encode_coding_object. */
5211 if (nchars
== E_WRITE_MAX
)
5212 coding
->raw_destination
= 1;
5214 encode_coding_object
5215 (coding
, string
, start
, string_char_to_byte (string
, start
),
5216 start
+ nchars
, string_char_to_byte (string
, start
+ nchars
),
5221 coding
->dst_object
= string
;
5222 coding
->consumed_char
= SCHARS (string
);
5223 coding
->produced
= SBYTES (string
);
5228 ptrdiff_t start_byte
= CHAR_TO_BYTE (start
);
5229 ptrdiff_t end_byte
= CHAR_TO_BYTE (end
);
5231 coding
->src_multibyte
= (end
- start
) < (end_byte
- start_byte
);
5232 if (CODING_REQUIRE_ENCODING (coding
))
5234 ptrdiff_t nchars
= min (end
- start
, E_WRITE_MAX
);
5237 if (nchars
== E_WRITE_MAX
)
5238 coding
->raw_destination
= 1;
5240 encode_coding_object
5241 (coding
, Fcurrent_buffer (), start
, start_byte
,
5242 start
+ nchars
, CHAR_TO_BYTE (start
+ nchars
), Qt
);
5246 coding
->dst_object
= Qnil
;
5247 coding
->dst_pos_byte
= start_byte
;
5248 if (start
>= GPT
|| end
<= GPT
)
5250 coding
->consumed_char
= end
- start
;
5251 coding
->produced
= end_byte
- start_byte
;
5255 coding
->consumed_char
= GPT
- start
;
5256 coding
->produced
= GPT_BYTE
- start_byte
;
5261 if (coding
->produced
> 0)
5263 char *buf
= (coding
->raw_destination
? (char *) coding
->destination
5264 : (STRINGP (coding
->dst_object
)
5265 ? SSDATA (coding
->dst_object
)
5266 : (char *) BYTE_POS_ADDR (coding
->dst_pos_byte
)));
5267 coding
->produced
-= emacs_write_sig (desc
, buf
, coding
->produced
);
5269 if (coding
->raw_destination
)
5271 /* We're responsible for freeing this, see
5272 encode_coding_object to check why. */
5273 xfree (coding
->destination
);
5274 coding
->raw_destination
= 0;
5276 if (coding
->produced
)
5279 start
+= coding
->consumed_char
;
5285 DEFUN ("verify-visited-file-modtime", Fverify_visited_file_modtime
,
5286 Sverify_visited_file_modtime
, 0, 1, 0,
5287 doc
: /* Return t if last mod time of BUF's visited file matches what BUF records.
5288 This means that the file has not been changed since it was visited or saved.
5289 If BUF is omitted or nil, it defaults to the current buffer.
5290 See Info node `(elisp)Modification Time' for more details. */)
5295 Lisp_Object handler
;
5296 Lisp_Object filename
;
5297 struct timespec mtime
;
5307 if (!STRINGP (BVAR (b
, filename
))) return Qt
;
5308 if (b
->modtime
.tv_nsec
== UNKNOWN_MODTIME_NSECS
) return Qt
;
5310 /* If the file name has special constructs in it,
5311 call the corresponding file handler. */
5312 handler
= Ffind_file_name_handler (BVAR (b
, filename
),
5313 Qverify_visited_file_modtime
);
5314 if (!NILP (handler
))
5315 return call2 (handler
, Qverify_visited_file_modtime
, buf
);
5317 filename
= ENCODE_FILE (BVAR (b
, filename
));
5319 mtime
= (stat (SSDATA (filename
), &st
) == 0
5320 ? get_stat_mtime (&st
)
5321 : time_error_value (errno
));
5322 if (timespec_cmp (mtime
, b
->modtime
) == 0
5323 && (b
->modtime_size
< 0
5324 || st
.st_size
== b
->modtime_size
))
5329 DEFUN ("visited-file-modtime", Fvisited_file_modtime
,
5330 Svisited_file_modtime
, 0, 0, 0,
5331 doc
: /* Return the current buffer's recorded visited file modification time.
5332 The value is a list of the form (HIGH LOW USEC PSEC), like the time values that
5333 `file-attributes' returns. If the current buffer has no recorded file
5334 modification time, this function returns 0. If the visited file
5335 doesn't exist, return -1.
5336 See Info node `(elisp)Modification Time' for more details. */)
5339 int ns
= current_buffer
->modtime
.tv_nsec
;
5341 return make_number (UNKNOWN_MODTIME_NSECS
- ns
);
5342 return make_lisp_time (current_buffer
->modtime
);
5345 DEFUN ("set-visited-file-modtime", Fset_visited_file_modtime
,
5346 Sset_visited_file_modtime
, 0, 1, 0,
5347 doc
: /* Update buffer's recorded modification time from the visited file's time.
5348 Useful if the buffer was not read from the file normally
5349 or if the file itself has been changed for some known benign reason.
5350 An argument specifies the modification time value to use
5351 \(instead of that of the visited file), in the form of a list
5352 \(HIGH LOW USEC PSEC) or an integer flag as returned by
5353 `visited-file-modtime'. */)
5354 (Lisp_Object time_flag
)
5356 if (!NILP (time_flag
))
5358 struct timespec mtime
;
5359 if (INTEGERP (time_flag
))
5361 CHECK_RANGED_INTEGER (time_flag
, -1, 0);
5362 mtime
= make_timespec (0, UNKNOWN_MODTIME_NSECS
- XINT (time_flag
));
5365 mtime
= lisp_time_argument (time_flag
);
5367 current_buffer
->modtime
= mtime
;
5368 current_buffer
->modtime_size
= -1;
5372 register Lisp_Object filename
;
5374 Lisp_Object handler
;
5376 filename
= Fexpand_file_name (BVAR (current_buffer
, filename
), Qnil
);
5378 /* If the file name has special constructs in it,
5379 call the corresponding file handler. */
5380 handler
= Ffind_file_name_handler (filename
, Qset_visited_file_modtime
);
5381 if (!NILP (handler
))
5382 /* The handler can find the file name the same way we did. */
5383 return call2 (handler
, Qset_visited_file_modtime
, Qnil
);
5385 filename
= ENCODE_FILE (filename
);
5387 if (stat (SSDATA (filename
), &st
) >= 0)
5389 current_buffer
->modtime
= get_stat_mtime (&st
);
5390 current_buffer
->modtime_size
= st
.st_size
;
5398 auto_save_error (Lisp_Object error_val
)
5400 Lisp_Object args
[3], msg
;
5402 struct gcpro gcpro1
;
5404 auto_save_error_occurred
= 1;
5406 ring_bell (XFRAME (selected_frame
));
5408 args
[0] = build_string ("Auto-saving %s: %s");
5409 args
[1] = BVAR (current_buffer
, name
);
5410 args
[2] = Ferror_message_string (error_val
);
5411 msg
= Fformat (3, args
);
5414 for (i
= 0; i
< 3; ++i
)
5419 message3_nolog (msg
);
5420 Fsleep_for (make_number (1), Qnil
);
5433 auto_save_mode_bits
= 0666;
5435 /* Get visited file's mode to become the auto save file's mode. */
5436 if (! NILP (BVAR (current_buffer
, filename
)))
5438 if (stat (SSDATA (BVAR (current_buffer
, filename
)), &st
) >= 0)
5439 /* But make sure we can overwrite it later! */
5440 auto_save_mode_bits
= (st
.st_mode
| 0600) & 0777;
5441 else if (modes
= Ffile_modes (BVAR (current_buffer
, filename
)),
5443 /* Remote files don't cooperate with stat. */
5444 auto_save_mode_bits
= (XINT (modes
) | 0600) & 0777;
5448 Fwrite_region (Qnil
, Qnil
, BVAR (current_buffer
, auto_save_file_name
), Qnil
,
5449 NILP (Vauto_save_visited_file_name
) ? Qlambda
: Qt
,
5453 struct auto_save_unwind
5460 do_auto_save_unwind (void *arg
)
5462 struct auto_save_unwind
*p
= arg
;
5463 FILE *stream
= p
->stream
;
5464 minibuffer_auto_raise
= p
->auto_raise
;
5475 do_auto_save_make_dir (Lisp_Object dir
)
5479 auto_saving_dir_umask
= 077;
5480 result
= call2 (Qmake_directory
, dir
, Qt
);
5481 auto_saving_dir_umask
= 0;
5486 do_auto_save_eh (Lisp_Object ignore
)
5488 auto_saving_dir_umask
= 0;
5492 DEFUN ("do-auto-save", Fdo_auto_save
, Sdo_auto_save
, 0, 2, "",
5493 doc
: /* Auto-save all buffers that need it.
5494 This is all buffers that have auto-saving enabled
5495 and are changed since last auto-saved.
5496 Auto-saving writes the buffer into a file
5497 so that your editing is not lost if the system crashes.
5498 This file is not the file you visited; that changes only when you save.
5499 Normally we run the normal hook `auto-save-hook' before saving.
5501 A non-nil NO-MESSAGE argument means do not print any message if successful.
5502 A non-nil CURRENT-ONLY argument means save only current buffer. */)
5503 (Lisp_Object no_message
, Lisp_Object current_only
)
5505 struct buffer
*old
= current_buffer
, *b
;
5506 Lisp_Object tail
, buf
, hook
;
5507 bool auto_saved
= 0;
5508 int do_handled_files
;
5510 FILE *stream
= NULL
;
5511 ptrdiff_t count
= SPECPDL_INDEX ();
5512 bool orig_minibuffer_auto_raise
= minibuffer_auto_raise
;
5513 bool old_message_p
= 0;
5514 struct auto_save_unwind auto_save_unwind
;
5515 struct gcpro gcpro1
, gcpro2
;
5517 if (max_specpdl_size
< specpdl_size
+ 40)
5518 max_specpdl_size
= specpdl_size
+ 40;
5523 if (NILP (no_message
))
5525 old_message_p
= push_message ();
5526 record_unwind_protect_void (pop_message_unwind
);
5529 /* Ordinarily don't quit within this function,
5530 but don't make it impossible to quit (in case we get hung in I/O). */
5534 /* No GCPRO needed, because (when it matters) all Lisp_Object variables
5535 point to non-strings reached from Vbuffer_alist. */
5537 hook
= intern ("auto-save-hook");
5538 safe_run_hooks (hook
);
5540 if (STRINGP (Vauto_save_list_file_name
))
5542 Lisp_Object listfile
;
5544 listfile
= Fexpand_file_name (Vauto_save_list_file_name
, Qnil
);
5546 /* Don't try to create the directory when shutting down Emacs,
5547 because creating the directory might signal an error, and
5548 that would leave Emacs in a strange state. */
5549 if (!NILP (Vrun_hooks
))
5553 GCPRO2 (dir
, listfile
);
5554 dir
= Ffile_name_directory (listfile
);
5555 if (NILP (Ffile_directory_p (dir
)))
5556 internal_condition_case_1 (do_auto_save_make_dir
,
5562 stream
= emacs_fopen (SSDATA (listfile
), "w");
5565 auto_save_unwind
.stream
= stream
;
5566 auto_save_unwind
.auto_raise
= minibuffer_auto_raise
;
5567 record_unwind_protect_ptr (do_auto_save_unwind
, &auto_save_unwind
);
5568 minibuffer_auto_raise
= 0;
5570 auto_save_error_occurred
= 0;
5572 /* On first pass, save all files that don't have handlers.
5573 On second pass, save all files that do have handlers.
5575 If Emacs is crashing, the handlers may tweak what is causing
5576 Emacs to crash in the first place, and it would be a shame if
5577 Emacs failed to autosave perfectly ordinary files because it
5578 couldn't handle some ange-ftp'd file. */
5580 for (do_handled_files
= 0; do_handled_files
< 2; do_handled_files
++)
5581 FOR_EACH_LIVE_BUFFER (tail
, buf
)
5585 /* Record all the buffers that have auto save mode
5586 in the special file that lists them. For each of these buffers,
5587 Record visited name (if any) and auto save name. */
5588 if (STRINGP (BVAR (b
, auto_save_file_name
))
5589 && stream
!= NULL
&& do_handled_files
== 0)
5592 if (!NILP (BVAR (b
, filename
)))
5594 fwrite (SDATA (BVAR (b
, filename
)), 1,
5595 SBYTES (BVAR (b
, filename
)), stream
);
5597 putc ('\n', stream
);
5598 fwrite (SDATA (BVAR (b
, auto_save_file_name
)), 1,
5599 SBYTES (BVAR (b
, auto_save_file_name
)), stream
);
5600 putc ('\n', stream
);
5604 if (!NILP (current_only
)
5605 && b
!= current_buffer
)
5608 /* Don't auto-save indirect buffers.
5609 The base buffer takes care of it. */
5613 /* Check for auto save enabled
5614 and file changed since last auto save
5615 and file changed since last real save. */
5616 if (STRINGP (BVAR (b
, auto_save_file_name
))
5617 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
5618 && BUF_AUTOSAVE_MODIFF (b
) < BUF_MODIFF (b
)
5619 /* -1 means we've turned off autosaving for a while--see below. */
5620 && XINT (BVAR (b
, save_length
)) >= 0
5621 && (do_handled_files
5622 || NILP (Ffind_file_name_handler (BVAR (b
, auto_save_file_name
),
5625 struct timespec before_time
= current_timespec ();
5626 struct timespec after_time
;
5628 /* If we had a failure, don't try again for 20 minutes. */
5629 if (b
->auto_save_failure_time
> 0
5630 && before_time
.tv_sec
- b
->auto_save_failure_time
< 1200)
5633 set_buffer_internal (b
);
5634 if (NILP (Vauto_save_include_big_deletions
)
5635 && (XFASTINT (BVAR (b
, save_length
)) * 10
5636 > (BUF_Z (b
) - BUF_BEG (b
)) * 13)
5637 /* A short file is likely to change a large fraction;
5638 spare the user annoying messages. */
5639 && XFASTINT (BVAR (b
, save_length
)) > 5000
5640 /* These messages are frequent and annoying for `*mail*'. */
5641 && !EQ (BVAR (b
, filename
), Qnil
)
5642 && NILP (no_message
))
5644 /* It has shrunk too much; turn off auto-saving here. */
5645 minibuffer_auto_raise
= orig_minibuffer_auto_raise
;
5646 message_with_string ("Buffer %s has shrunk a lot; auto save disabled in that buffer until next real save",
5648 minibuffer_auto_raise
= 0;
5649 /* Turn off auto-saving until there's a real save,
5650 and prevent any more warnings. */
5651 XSETINT (BVAR (b
, save_length
), -1);
5652 Fsleep_for (make_number (1), Qnil
);
5655 if (!auto_saved
&& NILP (no_message
))
5656 message1 ("Auto-saving...");
5657 internal_condition_case (auto_save_1
, Qt
, auto_save_error
);
5659 BUF_AUTOSAVE_MODIFF (b
) = BUF_MODIFF (b
);
5660 XSETFASTINT (BVAR (current_buffer
, save_length
), Z
- BEG
);
5661 set_buffer_internal (old
);
5663 after_time
= current_timespec ();
5665 /* If auto-save took more than 60 seconds,
5666 assume it was an NFS failure that got a timeout. */
5667 if (after_time
.tv_sec
- before_time
.tv_sec
> 60)
5668 b
->auto_save_failure_time
= after_time
.tv_sec
;
5672 /* Prevent another auto save till enough input events come in. */
5673 record_auto_save ();
5675 if (auto_saved
&& NILP (no_message
))
5679 /* If we are going to restore an old message,
5680 give time to read ours. */
5681 sit_for (make_number (1), 0, 0);
5684 else if (!auto_save_error_occurred
)
5685 /* Don't overwrite the error message if an error occurred.
5686 If we displayed a message and then restored a state
5687 with no message, leave a "done" message on the screen. */
5688 message1 ("Auto-saving...done");
5693 /* This restores the message-stack status. */
5694 unbind_to (count
, Qnil
);
5698 DEFUN ("set-buffer-auto-saved", Fset_buffer_auto_saved
,
5699 Sset_buffer_auto_saved
, 0, 0, 0,
5700 doc
: /* Mark current buffer as auto-saved with its current text.
5701 No auto-save file will be written until the buffer changes again. */)
5704 /* FIXME: This should not be called in indirect buffers, since
5705 they're not autosaved. */
5706 BUF_AUTOSAVE_MODIFF (current_buffer
) = MODIFF
;
5707 XSETFASTINT (BVAR (current_buffer
, save_length
), Z
- BEG
);
5708 current_buffer
->auto_save_failure_time
= 0;
5712 DEFUN ("clear-buffer-auto-save-failure", Fclear_buffer_auto_save_failure
,
5713 Sclear_buffer_auto_save_failure
, 0, 0, 0,
5714 doc
: /* Clear any record of a recent auto-save failure in the current buffer. */)
5717 current_buffer
->auto_save_failure_time
= 0;
5721 DEFUN ("recent-auto-save-p", Frecent_auto_save_p
, Srecent_auto_save_p
,
5723 doc
: /* Return t if current buffer has been auto-saved recently.
5724 More precisely, if it has been auto-saved since last read from or saved
5725 in the visited file. If the buffer has no visited file,
5726 then any auto-save counts as "recent". */)
5729 /* FIXME: maybe we should return nil for indirect buffers since
5730 they're never autosaved. */
5731 return (SAVE_MODIFF
< BUF_AUTOSAVE_MODIFF (current_buffer
) ? Qt
: Qnil
);
5734 /* Reading and completing file names */
5736 DEFUN ("next-read-file-uses-dialog-p", Fnext_read_file_uses_dialog_p
,
5737 Snext_read_file_uses_dialog_p
, 0, 0, 0,
5738 doc
: /* Return t if a call to `read-file-name' will use a dialog.
5739 The return value is only relevant for a call to `read-file-name' that happens
5740 before any other event (mouse or keypress) is handled. */)
5743 #if defined (USE_MOTIF) || defined (HAVE_NTGUI) || defined (USE_GTK) \
5744 || defined (HAVE_NS)
5745 if ((NILP (last_nonmenu_event
) || CONSP (last_nonmenu_event
))
5748 && window_system_available (SELECTED_FRAME ()))
5755 Fread_file_name (Lisp_Object prompt
, Lisp_Object dir
, Lisp_Object default_filename
, Lisp_Object mustmatch
, Lisp_Object initial
, Lisp_Object predicate
)
5757 struct gcpro gcpro1
;
5758 Lisp_Object args
[7];
5760 GCPRO1 (default_filename
);
5761 args
[0] = intern ("read-file-name");
5764 args
[3] = default_filename
;
5765 args
[4] = mustmatch
;
5767 args
[6] = predicate
;
5768 RETURN_UNGCPRO (Ffuncall (7, args
));
5775 valid_timestamp_file_system
= 0;
5777 /* fsync can be a significant performance hit. Often it doesn't
5778 suffice to make the file-save operation survive a crash. For
5779 batch scripts, which are typically part of larger shell commands
5780 that don't fsync other files, its effect on performance can be
5781 significant so its utility is particularly questionable.
5782 Hence, for now by default fsync is used only when interactive.
5784 For more on why fsync often fails to work on today's hardware, see:
5785 Zheng M et al. Understanding the robustness of SSDs under power fault.
5786 11th USENIX Conf. on File and Storage Technologies, 2013 (FAST '13), 271-84
5787 http://www.usenix.org/system/files/conference/fast13/fast13-final80.pdf
5789 For more on why fsync does not suffice even if it works properly, see:
5790 Roche X. Necessary step(s) to synchronize filename operations on disk.
5791 Austin Group Defect 672, 2013-03-19
5792 http://austingroupbugs.net/view.php?id=672 */
5793 write_region_inhibit_fsync
= noninteractive
;
5797 syms_of_fileio (void)
5799 DEFSYM (Qoperations
, "operations");
5800 DEFSYM (Qexpand_file_name
, "expand-file-name");
5801 DEFSYM (Qsubstitute_in_file_name
, "substitute-in-file-name");
5802 DEFSYM (Qdirectory_file_name
, "directory-file-name");
5803 DEFSYM (Qfile_name_directory
, "file-name-directory");
5804 DEFSYM (Qfile_name_nondirectory
, "file-name-nondirectory");
5805 DEFSYM (Qunhandled_file_name_directory
, "unhandled-file-name-directory");
5806 DEFSYM (Qfile_name_as_directory
, "file-name-as-directory");
5807 DEFSYM (Qcopy_file
, "copy-file");
5808 DEFSYM (Qmake_directory_internal
, "make-directory-internal");
5809 DEFSYM (Qmake_directory
, "make-directory");
5810 DEFSYM (Qdelete_directory_internal
, "delete-directory-internal");
5811 DEFSYM (Qdelete_file
, "delete-file");
5812 DEFSYM (Qrename_file
, "rename-file");
5813 DEFSYM (Qadd_name_to_file
, "add-name-to-file");
5814 DEFSYM (Qmake_symbolic_link
, "make-symbolic-link");
5815 DEFSYM (Qfile_exists_p
, "file-exists-p");
5816 DEFSYM (Qfile_executable_p
, "file-executable-p");
5817 DEFSYM (Qfile_readable_p
, "file-readable-p");
5818 DEFSYM (Qfile_writable_p
, "file-writable-p");
5819 DEFSYM (Qfile_symlink_p
, "file-symlink-p");
5820 DEFSYM (Qaccess_file
, "access-file");
5821 DEFSYM (Qfile_directory_p
, "file-directory-p");
5822 DEFSYM (Qfile_regular_p
, "file-regular-p");
5823 DEFSYM (Qfile_accessible_directory_p
, "file-accessible-directory-p");
5824 DEFSYM (Qfile_modes
, "file-modes");
5825 DEFSYM (Qset_file_modes
, "set-file-modes");
5826 DEFSYM (Qset_file_times
, "set-file-times");
5827 DEFSYM (Qfile_selinux_context
, "file-selinux-context");
5828 DEFSYM (Qset_file_selinux_context
, "set-file-selinux-context");
5829 DEFSYM (Qfile_acl
, "file-acl");
5830 DEFSYM (Qset_file_acl
, "set-file-acl");
5831 DEFSYM (Qfile_newer_than_file_p
, "file-newer-than-file-p");
5832 DEFSYM (Qinsert_file_contents
, "insert-file-contents");
5833 DEFSYM (Qchoose_write_coding_system
, "choose-write-coding-system");
5834 DEFSYM (Qwrite_region
, "write-region");
5835 DEFSYM (Qverify_visited_file_modtime
, "verify-visited-file-modtime");
5836 DEFSYM (Qset_visited_file_modtime
, "set-visited-file-modtime");
5837 DEFSYM (Qauto_save_coding
, "auto-save-coding");
5839 DEFSYM (Qfile_name_history
, "file-name-history");
5840 Fset (Qfile_name_history
, Qnil
);
5842 DEFSYM (Qfile_error
, "file-error");
5843 DEFSYM (Qfile_already_exists
, "file-already-exists");
5844 DEFSYM (Qfile_date_error
, "file-date-error");
5845 DEFSYM (Qfile_notify_error
, "file-notify-error");
5846 DEFSYM (Qexcl
, "excl");
5848 DEFVAR_LISP ("file-name-coding-system", Vfile_name_coding_system
,
5849 doc
: /* Coding system for encoding file names.
5850 If it is nil, `default-file-name-coding-system' (which see) is used. */);
5851 Vfile_name_coding_system
= Qnil
;
5853 DEFVAR_LISP ("default-file-name-coding-system",
5854 Vdefault_file_name_coding_system
,
5855 doc
: /* Default coding system for encoding file names.
5856 This variable is used only when `file-name-coding-system' is nil.
5858 This variable is set/changed by the command `set-language-environment'.
5859 User should not set this variable manually,
5860 instead use `file-name-coding-system' to get a constant encoding
5861 of file names regardless of the current language environment. */);
5862 Vdefault_file_name_coding_system
= Qnil
;
5864 DEFSYM (Qformat_decode
, "format-decode");
5865 DEFSYM (Qformat_annotate_function
, "format-annotate-function");
5866 DEFSYM (Qafter_insert_file_set_coding
, "after-insert-file-set-coding");
5867 DEFSYM (Qcar_less_than_car
, "car-less-than-car");
5869 Fput (Qfile_error
, Qerror_conditions
,
5870 Fpurecopy (list2 (Qfile_error
, Qerror
)));
5871 Fput (Qfile_error
, Qerror_message
,
5872 build_pure_c_string ("File error"));
5874 Fput (Qfile_already_exists
, Qerror_conditions
,
5875 Fpurecopy (list3 (Qfile_already_exists
, Qfile_error
, Qerror
)));
5876 Fput (Qfile_already_exists
, Qerror_message
,
5877 build_pure_c_string ("File already exists"));
5879 Fput (Qfile_date_error
, Qerror_conditions
,
5880 Fpurecopy (list3 (Qfile_date_error
, Qfile_error
, Qerror
)));
5881 Fput (Qfile_date_error
, Qerror_message
,
5882 build_pure_c_string ("Cannot set file date"));
5884 Fput (Qfile_notify_error
, Qerror_conditions
,
5885 Fpurecopy (list3 (Qfile_notify_error
, Qfile_error
, Qerror
)));
5886 Fput (Qfile_notify_error
, Qerror_message
,
5887 build_pure_c_string ("File notification error"));
5889 DEFVAR_LISP ("file-name-handler-alist", Vfile_name_handler_alist
,
5890 doc
: /* Alist of elements (REGEXP . HANDLER) for file names handled specially.
5891 If a file name matches REGEXP, all I/O on that file is done by calling
5892 HANDLER. If a file name matches more than one handler, the handler
5893 whose match starts last in the file name gets precedence. The
5894 function `find-file-name-handler' checks this list for a handler for
5897 HANDLER should be a function. The first argument given to it is the
5898 name of the I/O primitive to be handled; the remaining arguments are
5899 the arguments that were passed to that primitive. For example, if you
5900 do (file-exists-p FILENAME) and FILENAME is handled by HANDLER, then
5901 HANDLER is called like this:
5903 (funcall HANDLER 'file-exists-p FILENAME)
5905 Note that HANDLER must be able to handle all I/O primitives; if it has
5906 nothing special to do for a primitive, it should reinvoke the
5907 primitive to handle the operation \"the usual way\".
5908 See Info node `(elisp)Magic File Names' for more details. */);
5909 Vfile_name_handler_alist
= Qnil
;
5911 DEFVAR_LISP ("set-auto-coding-function",
5912 Vset_auto_coding_function
,
5913 doc
: /* If non-nil, a function to call to decide a coding system of file.
5914 Two arguments are passed to this function: the file name
5915 and the length of a file contents following the point.
5916 This function should return a coding system to decode the file contents.
5917 It should check the file name against `auto-coding-alist'.
5918 If no coding system is decided, it should check a coding system
5919 specified in the heading lines with the format:
5920 -*- ... coding: CODING-SYSTEM; ... -*-
5921 or local variable spec of the tailing lines with `coding:' tag. */);
5922 Vset_auto_coding_function
= Qnil
;
5924 DEFVAR_LISP ("after-insert-file-functions", Vafter_insert_file_functions
,
5925 doc
: /* A list of functions to be called at the end of `insert-file-contents'.
5926 Each is passed one argument, the number of characters inserted,
5927 with point at the start of the inserted text. Each function
5928 should leave point the same, and return the new character count.
5929 If `insert-file-contents' is intercepted by a handler from
5930 `file-name-handler-alist', that handler is responsible for calling the
5931 functions in `after-insert-file-functions' if appropriate. */);
5932 Vafter_insert_file_functions
= Qnil
;
5934 DEFVAR_LISP ("write-region-annotate-functions", Vwrite_region_annotate_functions
,
5935 doc
: /* A list of functions to be called at the start of `write-region'.
5936 Each is passed two arguments, START and END as for `write-region'.
5937 These are usually two numbers but not always; see the documentation
5938 for `write-region'. The function should return a list of pairs
5939 of the form (POSITION . STRING), consisting of strings to be effectively
5940 inserted at the specified positions of the file being written (1 means to
5941 insert before the first byte written). The POSITIONs must be sorted into
5944 If there are several annotation functions, the lists returned by these
5945 functions are merged destructively. As each annotation function runs,
5946 the variable `write-region-annotations-so-far' contains a list of all
5947 annotations returned by previous annotation functions.
5949 An annotation function can return with a different buffer current.
5950 Doing so removes the annotations returned by previous functions, and
5951 resets START and END to `point-min' and `point-max' of the new buffer.
5953 After `write-region' completes, Emacs calls the function stored in
5954 `write-region-post-annotation-function', once for each buffer that was
5955 current when building the annotations (i.e., at least once), with that
5956 buffer current. */);
5957 Vwrite_region_annotate_functions
= Qnil
;
5958 DEFSYM (Qwrite_region_annotate_functions
, "write-region-annotate-functions");
5960 DEFVAR_LISP ("write-region-post-annotation-function",
5961 Vwrite_region_post_annotation_function
,
5962 doc
: /* Function to call after `write-region' completes.
5963 The function is called with no arguments. If one or more of the
5964 annotation functions in `write-region-annotate-functions' changed the
5965 current buffer, the function stored in this variable is called for
5966 each of those additional buffers as well, in addition to the original
5967 buffer. The relevant buffer is current during each function call. */);
5968 Vwrite_region_post_annotation_function
= Qnil
;
5969 staticpro (&Vwrite_region_annotation_buffers
);
5971 DEFVAR_LISP ("write-region-annotations-so-far",
5972 Vwrite_region_annotations_so_far
,
5973 doc
: /* When an annotation function is called, this holds the previous annotations.
5974 These are the annotations made by other annotation functions
5975 that were already called. See also `write-region-annotate-functions'. */);
5976 Vwrite_region_annotations_so_far
= Qnil
;
5978 DEFVAR_LISP ("inhibit-file-name-handlers", Vinhibit_file_name_handlers
,
5979 doc
: /* A list of file name handlers that temporarily should not be used.
5980 This applies only to the operation `inhibit-file-name-operation'. */);
5981 Vinhibit_file_name_handlers
= Qnil
;
5983 DEFVAR_LISP ("inhibit-file-name-operation", Vinhibit_file_name_operation
,
5984 doc
: /* The operation for which `inhibit-file-name-handlers' is applicable. */);
5985 Vinhibit_file_name_operation
= Qnil
;
5987 DEFVAR_LISP ("auto-save-list-file-name", Vauto_save_list_file_name
,
5988 doc
: /* File name in which we write a list of all auto save file names.
5989 This variable is initialized automatically from `auto-save-list-file-prefix'
5990 shortly after Emacs reads your init file, if you have not yet given it
5991 a non-nil value. */);
5992 Vauto_save_list_file_name
= Qnil
;
5994 DEFVAR_LISP ("auto-save-visited-file-name", Vauto_save_visited_file_name
,
5995 doc
: /* Non-nil says auto-save a buffer in the file it is visiting, when practical.
5996 Normally auto-save files are written under other names. */);
5997 Vauto_save_visited_file_name
= Qnil
;
5999 DEFVAR_LISP ("auto-save-include-big-deletions", Vauto_save_include_big_deletions
,
6000 doc
: /* If non-nil, auto-save even if a large part of the text is deleted.
6001 If nil, deleting a substantial portion of the text disables auto-save
6002 in the buffer; this is the default behavior, because the auto-save
6003 file is usually more useful if it contains the deleted text. */);
6004 Vauto_save_include_big_deletions
= Qnil
;
6006 DEFVAR_BOOL ("write-region-inhibit-fsync", write_region_inhibit_fsync
,
6007 doc
: /* Non-nil means don't call fsync in `write-region'.
6008 This variable affects calls to `write-region' as well as save commands.
6009 Setting this to nil may avoid data loss if the system loses power or
6010 the operating system crashes. */);
6011 write_region_inhibit_fsync
= 0; /* See also `init_fileio' above. */
6013 DEFVAR_BOOL ("delete-by-moving-to-trash", delete_by_moving_to_trash
,
6014 doc
: /* Specifies whether to use the system's trash can.
6015 When non-nil, certain file deletion commands use the function
6016 `move-file-to-trash' instead of deleting files outright.
6017 This includes interactive calls to `delete-file' and
6018 `delete-directory' and the Dired deletion commands. */);
6019 delete_by_moving_to_trash
= 0;
6020 Qdelete_by_moving_to_trash
= intern_c_string ("delete-by-moving-to-trash");
6022 DEFSYM (Qmove_file_to_trash
, "move-file-to-trash");
6023 DEFSYM (Qcopy_directory
, "copy-directory");
6024 DEFSYM (Qdelete_directory
, "delete-directory");
6025 DEFSYM (Qsubstitute_env_in_file_name
, "substitute-env-in-file-name");
6027 defsubr (&Sfind_file_name_handler
);
6028 defsubr (&Sfile_name_directory
);
6029 defsubr (&Sfile_name_nondirectory
);
6030 defsubr (&Sunhandled_file_name_directory
);
6031 defsubr (&Sfile_name_as_directory
);
6032 defsubr (&Sdirectory_file_name
);
6033 defsubr (&Smake_temp_name
);
6034 defsubr (&Sexpand_file_name
);
6035 defsubr (&Ssubstitute_in_file_name
);
6036 defsubr (&Scopy_file
);
6037 defsubr (&Smake_directory_internal
);
6038 defsubr (&Sdelete_directory_internal
);
6039 defsubr (&Sdelete_file
);
6040 defsubr (&Srename_file
);
6041 defsubr (&Sadd_name_to_file
);
6042 defsubr (&Smake_symbolic_link
);
6043 defsubr (&Sfile_name_absolute_p
);
6044 defsubr (&Sfile_exists_p
);
6045 defsubr (&Sfile_executable_p
);
6046 defsubr (&Sfile_readable_p
);
6047 defsubr (&Sfile_writable_p
);
6048 defsubr (&Saccess_file
);
6049 defsubr (&Sfile_symlink_p
);
6050 defsubr (&Sfile_directory_p
);
6051 defsubr (&Sfile_accessible_directory_p
);
6052 defsubr (&Sfile_regular_p
);
6053 defsubr (&Sfile_modes
);
6054 defsubr (&Sset_file_modes
);
6055 defsubr (&Sset_file_times
);
6056 defsubr (&Sfile_selinux_context
);
6057 defsubr (&Sfile_acl
);
6058 defsubr (&Sset_file_acl
);
6059 defsubr (&Sset_file_selinux_context
);
6060 defsubr (&Sset_default_file_modes
);
6061 defsubr (&Sdefault_file_modes
);
6062 defsubr (&Sfile_newer_than_file_p
);
6063 defsubr (&Sinsert_file_contents
);
6064 defsubr (&Schoose_write_coding_system
);
6065 defsubr (&Swrite_region
);
6066 defsubr (&Scar_less_than_car
);
6067 defsubr (&Sverify_visited_file_modtime
);
6068 defsubr (&Svisited_file_modtime
);
6069 defsubr (&Sset_visited_file_modtime
);
6070 defsubr (&Sdo_auto_save
);
6071 defsubr (&Sset_buffer_auto_saved
);
6072 defsubr (&Sclear_buffer_auto_save_failure
);
6073 defsubr (&Srecent_auto_save_p
);
6075 defsubr (&Snext_read_file_uses_dialog_p
);
6078 defsubr (&Sunix_sync
);