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
);
464 /* FIXME: Figure out the multibyte vs unibyte stuff here. */
465 tem_fn
= make_specified_string (beg
, -1, p
- beg
,
466 STRING_MULTIBYTE (filename
));
469 tem_fn
= make_specified_string (beg
- 2, -1, p
- beg
+ 2,
470 STRING_MULTIBYTE (filename
));
472 else if (STRING_MULTIBYTE (filename
))
474 tem_fn
= make_specified_string (beg
, -1, p
- beg
, 1);
475 dostounix_filename (SSDATA (tem_fn
));
477 if (!NILP (Vw32_downcase_file_names
))
478 tem_fn
= Fdowncase (tem_fn
);
483 dostounix_filename (beg
);
484 tem_fn
= make_specified_string (beg
, -1, p
- beg
, 0);
488 return make_specified_string (beg
, -1, p
- beg
, STRING_MULTIBYTE (filename
));
492 DEFUN ("file-name-nondirectory", Ffile_name_nondirectory
,
493 Sfile_name_nondirectory
, 1, 1, 0,
494 doc
: /* Return file name FILENAME sans its directory.
495 For example, in a Unix-syntax file name,
496 this is everything after the last slash,
497 or the entire name if it contains no slash. */)
498 (Lisp_Object filename
)
500 register const char *beg
, *p
, *end
;
503 CHECK_STRING (filename
);
505 /* If the file name has special constructs in it,
506 call the corresponding file handler. */
507 handler
= Ffind_file_name_handler (filename
, Qfile_name_nondirectory
);
510 Lisp_Object handled_name
= call2 (handler
, Qfile_name_nondirectory
,
512 if (STRINGP (handled_name
))
514 error ("Invalid handler in `file-name-handler-alist'");
517 beg
= SSDATA (filename
);
518 end
= p
= beg
+ SBYTES (filename
);
520 while (p
!= beg
&& !IS_DIRECTORY_SEP (p
[-1])
522 /* only recognize drive specifier at beginning */
524 /* handle the "/:d:foo" case correctly */
525 && (p
== beg
+ 2 || (p
== beg
+ 4 && IS_DIRECTORY_SEP (*beg
))))
530 return make_specified_string (p
, -1, end
- p
, STRING_MULTIBYTE (filename
));
533 DEFUN ("unhandled-file-name-directory", Funhandled_file_name_directory
,
534 Sunhandled_file_name_directory
, 1, 1, 0,
535 doc
: /* Return a directly usable directory name somehow associated with FILENAME.
536 A `directly usable' directory name is one that may be used without the
537 intervention of any file handler.
538 If FILENAME is a directly usable file itself, return
539 \(file-name-directory FILENAME).
540 If FILENAME refers to a file which is not accessible from a local process,
541 then this should return nil.
542 The `call-process' and `start-process' functions use this function to
543 get a current directory to run processes in. */)
544 (Lisp_Object filename
)
548 /* If the file name has special constructs in it,
549 call the corresponding file handler. */
550 handler
= Ffind_file_name_handler (filename
, Qunhandled_file_name_directory
);
553 Lisp_Object handled_name
= call2 (handler
, Qunhandled_file_name_directory
,
555 return STRINGP (handled_name
) ? handled_name
: Qnil
;
558 return Ffile_name_directory (filename
);
561 /* Maximum number of bytes that DST will be longer than SRC
562 in file_name_as_directory. This occurs when SRCLEN == 0. */
563 enum { file_name_as_directory_slop
= 2 };
565 /* Convert from file name SRC of length SRCLEN to directory name in
566 DST. MULTIBYTE non-zero means the file name in SRC is a multibyte
567 string. On UNIX, just make sure there is a terminating /. Return
568 the length of DST in bytes. */
571 file_name_as_directory (char *dst
, const char *src
, ptrdiff_t srclen
,
582 memcpy (dst
, src
, srclen
);
583 if (!IS_DIRECTORY_SEP (dst
[srclen
- 1]))
584 dst
[srclen
++] = DIRECTORY_SEP
;
587 dostounix_filename (dst
);
592 DEFUN ("file-name-as-directory", Ffile_name_as_directory
,
593 Sfile_name_as_directory
, 1, 1, 0,
594 doc
: /* Return a string representing the file name FILE interpreted as a directory.
595 This operation exists because a directory is also a file, but its name as
596 a directory is different from its name as a file.
597 The result can be used as the value of `default-directory'
598 or passed as second argument to `expand-file-name'.
599 For a Unix-syntax file name, just appends a slash. */)
604 Lisp_Object handler
, val
;
611 /* If the file name has special constructs in it,
612 call the corresponding file handler. */
613 handler
= Ffind_file_name_handler (file
, Qfile_name_as_directory
);
616 Lisp_Object handled_name
= call2 (handler
, Qfile_name_as_directory
,
618 if (STRINGP (handled_name
))
620 error ("Invalid handler in `file-name-handler-alist'");
624 if (!NILP (Vw32_downcase_file_names
))
625 file
= Fdowncase (file
);
627 buf
= SAFE_ALLOCA (SBYTES (file
) + file_name_as_directory_slop
+ 1);
628 length
= file_name_as_directory (buf
, SSDATA (file
), SBYTES (file
),
629 STRING_MULTIBYTE (file
));
630 val
= make_specified_string (buf
, -1, length
, STRING_MULTIBYTE (file
));
635 /* Convert from directory name SRC of length SRCLEN to file name in
636 DST. MULTIBYTE non-zero means the file name in SRC is a multibyte
637 string. On UNIX, just make sure there isn't a terminating /.
638 Return the length of DST in bytes. */
641 directory_file_name (char *dst
, char *src
, ptrdiff_t srclen
, bool multibyte
)
643 /* Process as Unix format: just remove any final slash.
644 But leave "/" and "//" unchanged. */
647 && !IS_ANY_SEP (src
[srclen
- 2])
649 && IS_DIRECTORY_SEP (src
[srclen
- 1])
650 && ! (srclen
== 2 && IS_DIRECTORY_SEP (src
[0])))
653 memcpy (dst
, src
, srclen
);
656 dostounix_filename (dst
);
661 DEFUN ("directory-file-name", Fdirectory_file_name
, Sdirectory_file_name
,
663 doc
: /* Returns the file name of the directory named DIRECTORY.
664 This is the name of the file that holds the data for the directory DIRECTORY.
665 This operation exists because a directory is also a file, but its name as
666 a directory is different from its name as a file.
667 In Unix-syntax, this function just removes the final slash. */)
668 (Lisp_Object directory
)
672 Lisp_Object handler
, val
;
675 CHECK_STRING (directory
);
677 if (NILP (directory
))
680 /* If the file name has special constructs in it,
681 call the corresponding file handler. */
682 handler
= Ffind_file_name_handler (directory
, Qdirectory_file_name
);
685 Lisp_Object handled_name
= call2 (handler
, Qdirectory_file_name
,
687 if (STRINGP (handled_name
))
689 error ("Invalid handler in `file-name-handler-alist'");
693 if (!NILP (Vw32_downcase_file_names
))
694 directory
= Fdowncase (directory
);
696 buf
= SAFE_ALLOCA (SBYTES (directory
) + 1);
697 length
= directory_file_name (buf
, SSDATA (directory
), SBYTES (directory
),
698 STRING_MULTIBYTE (directory
));
699 val
= make_specified_string (buf
, -1, length
, STRING_MULTIBYTE (directory
));
704 static const char make_temp_name_tbl
[64] =
706 'A','B','C','D','E','F','G','H',
707 'I','J','K','L','M','N','O','P',
708 'Q','R','S','T','U','V','W','X',
709 'Y','Z','a','b','c','d','e','f',
710 'g','h','i','j','k','l','m','n',
711 'o','p','q','r','s','t','u','v',
712 'w','x','y','z','0','1','2','3',
713 '4','5','6','7','8','9','-','_'
716 static unsigned make_temp_name_count
, make_temp_name_count_initialized_p
;
718 /* Value is a temporary file name starting with PREFIX, a string.
720 The Emacs process number forms part of the result, so there is
721 no danger of generating a name being used by another process.
722 In addition, this function makes an attempt to choose a name
723 which has no existing file. To make this work, PREFIX should be
724 an absolute file name.
726 BASE64_P means add the pid as 3 characters in base64
727 encoding. In this case, 6 characters will be added to PREFIX to
728 form the file name. Otherwise, if Emacs is running on a system
729 with long file names, add the pid as a decimal number.
731 This function signals an error if no unique file name could be
735 make_temp_name (Lisp_Object prefix
, bool base64_p
)
737 Lisp_Object val
, encoded_prefix
;
741 char pidbuf
[INT_BUFSIZE_BOUND (printmax_t
)];
744 CHECK_STRING (prefix
);
746 /* VAL is created by adding 6 characters to PREFIX. The first
747 three are the PID of this process, in base 64, and the second
748 three are incremented if the file already exists. This ensures
749 262144 unique file names per PID per PREFIX. */
755 pidbuf
[0] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
756 pidbuf
[1] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
757 pidbuf
[2] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
762 #ifdef HAVE_LONG_FILE_NAMES
763 pidlen
= sprintf (pidbuf
, "%"pMd
, pid
);
765 pidbuf
[0] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
766 pidbuf
[1] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
767 pidbuf
[2] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
772 encoded_prefix
= ENCODE_FILE (prefix
);
773 len
= SBYTES (encoded_prefix
);
774 val
= make_uninit_string (len
+ 3 + pidlen
);
776 memcpy (data
, SSDATA (encoded_prefix
), len
);
779 memcpy (p
, pidbuf
, pidlen
);
782 /* Here we try to minimize useless stat'ing when this function is
783 invoked many times successively with the same PREFIX. We achieve
784 this by initializing count to a random value, and incrementing it
787 We don't want make-temp-name to be called while dumping,
788 because then make_temp_name_count_initialized_p would get set
789 and then make_temp_name_count would not be set when Emacs starts. */
791 if (!make_temp_name_count_initialized_p
)
793 make_temp_name_count
= time (NULL
);
794 make_temp_name_count_initialized_p
= 1;
799 unsigned num
= make_temp_name_count
;
801 p
[0] = make_temp_name_tbl
[num
& 63], num
>>= 6;
802 p
[1] = make_temp_name_tbl
[num
& 63], num
>>= 6;
803 p
[2] = make_temp_name_tbl
[num
& 63], num
>>= 6;
805 /* Poor man's congruential RN generator. Replace with
806 ++make_temp_name_count for debugging. */
807 make_temp_name_count
+= 25229;
808 make_temp_name_count
%= 225307;
810 if (!check_existing (data
))
812 /* We want to return only if errno is ENOENT. */
814 return DECODE_FILE (val
);
816 /* The error here is dubious, but there is little else we
817 can do. The alternatives are to return nil, which is
818 as bad as (and in many cases worse than) throwing the
819 error, or to ignore the error, which will likely result
820 in looping through 225307 stat's, which is not only
821 dog-slow, but also useless since eventually nil would
822 have to be returned anyway. */
823 report_file_error ("Cannot create temporary name for prefix",
831 DEFUN ("make-temp-name", Fmake_temp_name
, Smake_temp_name
, 1, 1, 0,
832 doc
: /* Generate temporary file name (string) starting with PREFIX (a string).
833 The Emacs process number forms part of the result,
834 so there is no danger of generating a name being used by another process.
836 In addition, this function makes an attempt to choose a name
837 which has no existing file. To make this work,
838 PREFIX should be an absolute file name.
840 There is a race condition between calling `make-temp-name' and creating the
841 file which opens all kinds of security holes. For that reason, you should
842 probably use `make-temp-file' instead, except in three circumstances:
844 * If you are creating the file in the user's home directory.
845 * If you are creating a directory rather than an ordinary file.
846 * If you are taking special precautions as `make-temp-file' does. */)
849 return make_temp_name (prefix
, 0);
854 DEFUN ("expand-file-name", Fexpand_file_name
, Sexpand_file_name
, 1, 2, 0,
855 doc
: /* Convert filename NAME to absolute, and canonicalize it.
856 Second arg DEFAULT-DIRECTORY is directory to start with if NAME is relative
857 \(does not start with slash or tilde); both the directory name and
858 a directory's file name are accepted. If DEFAULT-DIRECTORY is nil or
859 missing, the current buffer's value of `default-directory' is used.
860 NAME should be a string that is a valid file name for the underlying
862 File name components that are `.' are removed, and
863 so are file name components followed by `..', along with the `..' itself;
864 note that these simplifications are done without checking the resulting
865 file names in the file system.
866 Multiple consecutive slashes are collapsed into a single slash,
867 except at the beginning of the file name when they are significant (e.g.,
868 UNC file names on MS-Windows.)
869 An initial `~/' expands to your home directory.
870 An initial `~USER/' expands to USER's home directory.
871 See also the function `substitute-in-file-name'.
873 For technical reasons, this function can return correct but
874 non-intuitive results for the root directory; for instance,
875 \(expand-file-name ".." "/") returns "/..". For this reason, use
876 \(directory-file-name (file-name-directory dirname)) to traverse a
877 filesystem tree, not (expand-file-name ".." dirname). */)
878 (Lisp_Object name
, Lisp_Object default_directory
)
880 /* These point to SDATA and need to be careful with string-relocation
881 during GC (via DECODE_FILE). */
884 /* This should only point to alloca'd data. */
891 bool collapse_newdir
= 1;
895 Lisp_Object handler
, result
, handled_name
;
902 /* If the file name has special constructs in it,
903 call the corresponding file handler. */
904 handler
= Ffind_file_name_handler (name
, Qexpand_file_name
);
907 handled_name
= call3 (handler
, Qexpand_file_name
,
908 name
, default_directory
);
909 if (STRINGP (handled_name
))
911 error ("Invalid handler in `file-name-handler-alist'");
915 /* Use the buffer's default-directory if DEFAULT_DIRECTORY is omitted. */
916 if (NILP (default_directory
))
917 default_directory
= BVAR (current_buffer
, directory
);
918 if (! STRINGP (default_directory
))
921 /* "/" is not considered a root directory on DOS_NT, so using "/"
922 here causes an infinite recursion in, e.g., the following:
924 (let (default-directory)
925 (expand-file-name "a"))
927 To avoid this, we set default_directory to the root of the
929 default_directory
= build_string (emacs_root_dir ());
931 default_directory
= build_string ("/");
935 if (!NILP (default_directory
))
937 handler
= Ffind_file_name_handler (default_directory
, Qexpand_file_name
);
940 handled_name
= call3 (handler
, Qexpand_file_name
,
941 name
, default_directory
);
942 if (STRINGP (handled_name
))
944 error ("Invalid handler in `file-name-handler-alist'");
949 char *o
= SSDATA (default_directory
);
951 /* Make sure DEFAULT_DIRECTORY is properly expanded.
952 It would be better to do this down below where we actually use
953 default_directory. Unfortunately, calling Fexpand_file_name recursively
954 could invoke GC, and the strings might be relocated. This would
955 be annoying because we have pointers into strings lying around
956 that would need adjusting, and people would add new pointers to
957 the code and forget to adjust them, resulting in intermittent bugs.
958 Putting this call here avoids all that crud.
960 The EQ test avoids infinite recursion. */
961 if (! NILP (default_directory
) && !EQ (default_directory
, name
)
962 /* Save time in some common cases - as long as default_directory
963 is not relative, it can be canonicalized with name below (if it
964 is needed at all) without requiring it to be expanded now. */
966 /* Detect MSDOS file names with drive specifiers. */
967 && ! (IS_DRIVE (o
[0]) && IS_DEVICE_SEP (o
[1])
968 && IS_DIRECTORY_SEP (o
[2]))
970 /* Detect Windows file names in UNC format. */
971 && ! (IS_DIRECTORY_SEP (o
[0]) && IS_DIRECTORY_SEP (o
[1]))
973 #else /* not DOS_NT */
974 /* Detect Unix absolute file names (/... alone is not absolute on
976 && ! (IS_DIRECTORY_SEP (o
[0]))
977 #endif /* not DOS_NT */
983 default_directory
= Fexpand_file_name (default_directory
, Qnil
);
987 multibyte
= STRING_MULTIBYTE (name
);
988 if (multibyte
!= STRING_MULTIBYTE (default_directory
))
992 unsigned char *p
= SDATA (name
);
994 while (*p
&& ASCII_BYTE_P (*p
))
998 /* NAME is a pure ASCII string, and DEFAULT_DIRECTORY is
999 unibyte. Do not convert DEFAULT_DIRECTORY to
1000 multibyte; instead, convert NAME to a unibyte string,
1001 so that the result of this function is also a unibyte
1002 string. This is needed during bootstrapping and
1003 dumping, when Emacs cannot decode file names, because
1004 the locale environment is not set up. */
1005 name
= make_unibyte_string (SSDATA (name
), SBYTES (name
));
1009 default_directory
= string_to_multibyte (default_directory
);
1013 name
= string_to_multibyte (name
);
1019 if (!NILP (Vw32_downcase_file_names
))
1020 default_directory
= Fdowncase (default_directory
);
1023 /* Make a local copy of nm[] to protect it from GC in DECODE_FILE below. */
1024 nm
= xlispstrdupa (name
);
1027 /* Note if special escape prefix is present, but remove for now. */
1028 if (nm
[0] == '/' && nm
[1] == ':')
1034 /* Find and remove drive specifier if present; this makes nm absolute
1035 even if the rest of the name appears to be relative. Only look for
1036 drive specifier at the beginning. */
1037 if (IS_DRIVE (nm
[0]) && IS_DEVICE_SEP (nm
[1]))
1039 drive
= (unsigned char) nm
[0];
1044 /* If we see "c://somedir", we want to strip the first slash after the
1045 colon when stripping the drive letter. Otherwise, this expands to
1047 if (drive
&& IS_DIRECTORY_SEP (nm
[0]) && IS_DIRECTORY_SEP (nm
[1]))
1050 /* Discard any previous drive specifier if nm is now in UNC format. */
1051 if (IS_DIRECTORY_SEP (nm
[0]) && IS_DIRECTORY_SEP (nm
[1]))
1055 #endif /* WINDOWSNT */
1058 /* If nm is absolute, look for `/./' or `/../' or `//''sequences; if
1059 none are found, we can probably return right away. We will avoid
1060 allocating a new string if name is already fully expanded. */
1062 IS_DIRECTORY_SEP (nm
[0])
1064 && drive
&& !is_escaped
1067 && (drive
|| IS_DIRECTORY_SEP (nm
[1])) && !is_escaped
1071 /* If it turns out that the filename we want to return is just a
1072 suffix of FILENAME, we don't need to go through and edit
1073 things; we just need to construct a new string using data
1074 starting at the middle of FILENAME. If we set LOSE, that
1075 means we've discovered that we can't do that cool trick. */
1081 /* Since we know the name is absolute, we can assume that each
1082 element starts with a "/". */
1084 /* "." and ".." are hairy. */
1085 if (IS_DIRECTORY_SEP (p
[0])
1087 && (IS_DIRECTORY_SEP (p
[2])
1089 || (p
[2] == '.' && (IS_DIRECTORY_SEP (p
[3])
1092 /* Replace multiple slashes with a single one, except
1093 leave leading "//" alone. */
1094 else if (IS_DIRECTORY_SEP (p
[0])
1095 && IS_DIRECTORY_SEP (p
[1])
1096 && (p
!= nm
|| IS_DIRECTORY_SEP (p
[2])))
1103 /* Make sure directories are all separated with /, but
1104 avoid allocation of a new string when not required. */
1105 /* FIXME: Figure out multibyte and downcase here. */
1106 dostounix_filename (nm
);
1108 if (IS_DIRECTORY_SEP (nm
[1]))
1110 if (strcmp (nm
, SSDATA (name
)) != 0)
1111 name
= make_specified_string (nm
, -1, strlen (nm
), multibyte
);
1115 /* Drive must be set, so this is okay. */
1116 if (strcmp (nm
- 2, SSDATA (name
)) != 0)
1120 name
= make_specified_string (nm
, -1, p
- nm
, multibyte
);
1121 temp
[0] = DRIVE_LETTER (drive
);
1122 name
= concat2 (build_string (temp
), name
);
1125 if (!NILP (Vw32_downcase_file_names
))
1126 name
= Fdowncase (name
);
1129 #else /* not DOS_NT */
1130 if (strcmp (nm
, SSDATA (name
)) == 0)
1132 return make_specified_string (nm
, -1, strlen (nm
), multibyte
);
1133 #endif /* not DOS_NT */
1137 /* At this point, nm might or might not be an absolute file name. We
1138 need to expand ~ or ~user if present, otherwise prefix nm with
1139 default_directory if nm is not absolute, and finally collapse /./
1140 and /foo/../ sequences.
1142 We set newdir to be the appropriate prefix if one is needed:
1143 - the relevant user directory if nm starts with ~ or ~user
1144 - the specified drive's working dir (DOS/NT only) if nm does not
1146 - the value of default_directory.
1148 Note that these prefixes are not guaranteed to be absolute (except
1149 for the working dir of a drive). Therefore, to ensure we always
1150 return an absolute name, if the final prefix is not absolute we
1151 append it to the current working directory. */
1155 if (nm
[0] == '~') /* prefix ~ */
1157 if (IS_DIRECTORY_SEP (nm
[1])
1158 || nm
[1] == 0) /* ~ by itself */
1162 if (!(newdir
= egetenv ("HOME")))
1165 /* `egetenv' may return a unibyte string, which will bite us since
1166 we expect the directory to be multibyte. */
1167 tem
= build_string (newdir
);
1168 if (multibyte
&& !STRING_MULTIBYTE (tem
))
1170 hdir
= DECODE_FILE (tem
);
1171 newdir
= SSDATA (hdir
);
1174 collapse_newdir
= 0;
1177 else /* ~user/filename */
1180 for (p
= nm
; *p
&& !IS_DIRECTORY_SEP (*p
); p
++)
1182 o
= SAFE_ALLOCA (p
- nm
+ 1);
1183 memcpy (o
, nm
, p
- nm
);
1187 pw
= getpwnam (o
+ 1);
1193 newdir
= pw
->pw_dir
;
1194 /* `getpwnam' may return a unibyte string, which will
1195 bite us since we expect the directory to be
1197 tem
= build_string (newdir
);
1198 if (multibyte
&& !STRING_MULTIBYTE (tem
))
1200 hdir
= DECODE_FILE (tem
);
1201 newdir
= SSDATA (hdir
);
1205 collapse_newdir
= 0;
1209 /* If we don't find a user of that name, leave the name
1210 unchanged; don't move nm forward to p. */
1215 /* On DOS and Windows, nm is absolute if a drive name was specified;
1216 use the drive's current directory as the prefix if needed. */
1217 if (!newdir
&& drive
)
1219 /* Get default directory if needed to make nm absolute. */
1221 if (!IS_DIRECTORY_SEP (nm
[0]))
1223 adir
= alloca (MAXPATHLEN
+ 1);
1224 if (!getdefdir (c_toupper (drive
) - 'A' + 1, adir
))
1228 Lisp_Object tem
= build_string (adir
);
1230 tem
= DECODE_FILE (tem
);
1231 memcpy (adir
, SSDATA (tem
), SBYTES (tem
) + 1);
1236 /* Either nm starts with /, or drive isn't mounted. */
1238 adir
[0] = DRIVE_LETTER (drive
);
1247 /* Finally, if no prefix has been specified and nm is not absolute,
1248 then it must be expanded relative to default_directory. */
1252 /* /... alone is not absolute on DOS and Windows. */
1253 && !IS_DIRECTORY_SEP (nm
[0])
1256 && !(IS_DIRECTORY_SEP (nm
[0]) && IS_DIRECTORY_SEP (nm
[1]))
1260 newdir
= SSDATA (default_directory
);
1262 /* Note if special escape prefix is present, but remove for now. */
1263 if (newdir
[0] == '/' && newdir
[1] == ':')
1274 /* First ensure newdir is an absolute name. */
1276 /* Detect MSDOS file names with drive specifiers. */
1277 ! (IS_DRIVE (newdir
[0])
1278 && IS_DEVICE_SEP (newdir
[1]) && IS_DIRECTORY_SEP (newdir
[2]))
1280 /* Detect Windows file names in UNC format. */
1281 && ! (IS_DIRECTORY_SEP (newdir
[0]) && IS_DIRECTORY_SEP (newdir
[1]))
1285 /* Effectively, let newdir be (expand-file-name newdir cwd).
1286 Because of the admonition against calling expand-file-name
1287 when we have pointers into lisp strings, we accomplish this
1288 indirectly by prepending newdir to nm if necessary, and using
1289 cwd (or the wd of newdir's drive) as the new newdir. */
1292 const int adir_size
= MAX_UTF8_PATH
;
1294 const int adir_size
= MAXPATHLEN
+ 1;
1297 if (IS_DRIVE (newdir
[0]) && IS_DEVICE_SEP (newdir
[1]))
1299 drive
= (unsigned char) newdir
[0];
1302 if (!IS_DIRECTORY_SEP (nm
[0]))
1304 ptrdiff_t newlen
= strlen (newdir
);
1305 char *tmp
= alloca (newlen
+ file_name_as_directory_slop
1307 file_name_as_directory (tmp
, newdir
, newlen
, multibyte
);
1311 adir
= alloca (adir_size
);
1314 if (!getdefdir (c_toupper (drive
) - 'A' + 1, adir
))
1318 getcwd (adir
, adir_size
);
1321 Lisp_Object tem
= build_string (adir
);
1323 tem
= DECODE_FILE (tem
);
1324 memcpy (adir
, SSDATA (tem
), SBYTES (tem
) + 1);
1329 /* Strip off drive name from prefix, if present. */
1330 if (IS_DRIVE (newdir
[0]) && IS_DEVICE_SEP (newdir
[1]))
1336 /* Keep only a prefix from newdir if nm starts with slash
1337 (//server/share for UNC, nothing otherwise). */
1338 if (IS_DIRECTORY_SEP (nm
[0]) && collapse_newdir
)
1341 if (IS_DIRECTORY_SEP (newdir
[0]) && IS_DIRECTORY_SEP (newdir
[1]))
1343 char *adir
= strcpy (alloca (strlen (newdir
) + 1), newdir
);
1345 while (*p
&& !IS_DIRECTORY_SEP (*p
)) p
++;
1347 while (*p
&& !IS_DIRECTORY_SEP (*p
)) p
++;
1360 /* Ignore any slash at the end of newdir, unless newdir is
1361 just "/" or "//". */
1362 length
= strlen (newdir
);
1363 while (length
> 1 && IS_DIRECTORY_SEP (newdir
[length
- 1])
1364 && ! (length
== 2 && IS_DIRECTORY_SEP (newdir
[0])))
1370 /* Now concatenate the directory and name to new space in the stack frame. */
1371 tlen
= length
+ file_name_as_directory_slop
+ strlen (nm
) + 1;
1373 /* Reserve space for drive specifier and escape prefix, since either
1374 or both may need to be inserted. (The Microsoft x86 compiler
1375 produces incorrect code if the following two lines are combined.) */
1376 target
= alloca (tlen
+ 4);
1378 #else /* not DOS_NT */
1379 target
= SAFE_ALLOCA (tlen
);
1380 #endif /* not DOS_NT */
1385 if (nm
[0] == 0 || IS_DIRECTORY_SEP (nm
[0]))
1388 /* If newdir is effectively "C:/", then the drive letter will have
1389 been stripped and newdir will be "/". Concatenating with an
1390 absolute directory in nm produces "//", which will then be
1391 incorrectly treated as a network share. Ignore newdir in
1392 this case (keeping the drive letter). */
1393 if (!(drive
&& nm
[0] && IS_DIRECTORY_SEP (newdir
[0])
1394 && newdir
[1] == '\0'))
1397 memcpy (target
, newdir
, length
);
1402 file_name_as_directory (target
, newdir
, length
, multibyte
);
1405 strcat (target
, nm
);
1407 /* Now canonicalize by removing `//', `/.' and `/foo/..' if they
1415 if (!IS_DIRECTORY_SEP (*p
))
1419 else if (p
[1] == '.'
1420 && (IS_DIRECTORY_SEP (p
[2])
1423 /* If "/." is the entire filename, keep the "/". Otherwise,
1424 just delete the whole "/.". */
1425 if (o
== target
&& p
[2] == '\0')
1429 else if (p
[1] == '.' && p
[2] == '.'
1430 /* `/../' is the "superroot" on certain file systems.
1431 Turned off on DOS_NT systems because they have no
1432 "superroot" and because this causes us to produce
1433 file names like "d:/../foo" which fail file-related
1434 functions of the underlying OS. (To reproduce, try a
1435 long series of "../../" in default_directory, longer
1436 than the number of levels from the root.) */
1440 && (IS_DIRECTORY_SEP (p
[3]) || p
[3] == 0))
1445 while (o
!= target
&& (--o
, !IS_DIRECTORY_SEP (*o
)))
1448 /* Don't go below server level in UNC filenames. */
1449 if (o
== target
+ 1 && IS_DIRECTORY_SEP (*o
)
1450 && IS_DIRECTORY_SEP (*target
))
1454 /* Keep initial / only if this is the whole name. */
1455 if (o
== target
&& IS_ANY_SEP (*o
) && p
[3] == 0)
1459 else if (IS_DIRECTORY_SEP (p
[1])
1460 && (p
!= target
|| IS_DIRECTORY_SEP (p
[2])))
1461 /* Collapse multiple "/", except leave leading "//" alone. */
1470 /* At last, set drive name. */
1472 /* Except for network file name. */
1473 if (!(IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1])))
1474 #endif /* WINDOWSNT */
1476 if (!drive
) emacs_abort ();
1478 target
[0] = DRIVE_LETTER (drive
);
1481 /* Reinsert the escape prefix if required. */
1488 result
= make_specified_string (target
, -1, o
- target
, multibyte
);
1489 /* FIXME: Figure out the multibyte and downcase here. */
1490 dostounix_filename (SSDATA (result
));
1492 if (!NILP (Vw32_downcase_file_names
))
1493 result
= Fdowncase (result
);
1496 result
= make_specified_string (target
, -1, o
- target
, multibyte
);
1497 #endif /* !DOS_NT */
1500 /* Again look to see if the file name has special constructs in it
1501 and perhaps call the corresponding file handler. This is needed
1502 for filenames such as "/foo/../user@host:/bar/../baz". Expanding
1503 the ".." component gives us "/user@host:/bar/../baz" which needs
1504 to be expanded again. */
1505 handler
= Ffind_file_name_handler (result
, Qexpand_file_name
);
1506 if (!NILP (handler
))
1508 handled_name
= call3 (handler
, Qexpand_file_name
,
1509 result
, default_directory
);
1510 if (! STRINGP (handled_name
))
1511 error ("Invalid handler in `file-name-handler-alist'");
1512 result
= handled_name
;
1520 /* PLEASE DO NOT DELETE THIS COMMENTED-OUT VERSION!
1521 This is the old version of expand-file-name, before it was thoroughly
1522 rewritten for Emacs 10.31. We leave this version here commented-out,
1523 because the code is very complex and likely to have subtle bugs. If
1524 bugs _are_ found, it might be of interest to look at the old code and
1525 see what did it do in the relevant situation.
1527 Don't remove this code: it's true that it will be accessible
1528 from the repository, but a few years from deletion, people will
1529 forget it is there. */
1531 /* Changed this DEFUN to a DEAFUN, so as not to confuse `make-docfile'. */
1532 DEAFUN ("expand-file-name", Fexpand_file_name
, Sexpand_file_name
, 1, 2, 0,
1533 "Convert FILENAME to absolute, and canonicalize it.\n\
1534 Second arg DEFAULT is directory to start with if FILENAME is relative\n\
1535 \(does not start with slash); if DEFAULT is nil or missing,\n\
1536 the current buffer's value of default-directory is used.\n\
1537 Filenames containing `.' or `..' as components are simplified;\n\
1538 initial `~/' expands to your home directory.\n\
1539 See also the function `substitute-in-file-name'.")
1541 Lisp_Object name
, defalt
;
1545 register unsigned char *newdir
, *p
, *o
;
1547 unsigned char *target
;
1550 CHECK_STRING (name
);
1553 /* If nm is absolute, flush ...// and detect /./ and /../.
1554 If no /./ or /../ we can return right away. */
1561 if (p
[0] == '/' && p
[1] == '/')
1563 if (p
[0] == '/' && p
[1] == '~')
1564 nm
= p
+ 1, lose
= 1;
1565 if (p
[0] == '/' && p
[1] == '.'
1566 && (p
[2] == '/' || p
[2] == 0
1567 || (p
[2] == '.' && (p
[3] == '/' || p
[3] == 0))))
1573 if (nm
== SDATA (name
))
1575 return build_string (nm
);
1579 /* Now determine directory to start with and put it in NEWDIR. */
1583 if (nm
[0] == '~') /* prefix ~ */
1584 if (nm
[1] == '/' || nm
[1] == 0)/* ~/filename */
1586 if (!(newdir
= (unsigned char *) egetenv ("HOME")))
1587 newdir
= (unsigned char *) "";
1590 else /* ~user/filename */
1592 /* Get past ~ to user. */
1593 unsigned char *user
= nm
+ 1;
1594 /* Find end of name. */
1595 unsigned char *ptr
= (unsigned char *) strchr (user
, '/');
1596 ptrdiff_t len
= ptr
? ptr
- user
: strlen (user
);
1597 /* Copy the user name into temp storage. */
1598 o
= alloca (len
+ 1);
1599 memcpy (o
, user
, len
);
1602 /* Look up the user name. */
1604 pw
= (struct passwd
*) getpwnam (o
+ 1);
1607 error ("\"%s\" isn't a registered user", o
+ 1);
1609 newdir
= (unsigned char *) pw
->pw_dir
;
1611 /* Discard the user name from NM. */
1615 if (nm
[0] != '/' && !newdir
)
1618 defalt
= current_buffer
->directory
;
1619 CHECK_STRING (defalt
);
1620 newdir
= SDATA (defalt
);
1623 /* Now concatenate the directory and name to new space in the stack frame. */
1625 tlen
= (newdir
? strlen (newdir
) + 1 : 0) + strlen (nm
) + 1;
1626 target
= alloca (tlen
);
1631 if (nm
[0] == 0 || nm
[0] == '/')
1632 strcpy (target
, newdir
);
1634 file_name_as_directory (target
, newdir
);
1637 strcat (target
, nm
);
1639 /* Now canonicalize by removing /. and /foo/.. if they appear. */
1650 else if (!strncmp (p
, "//", 2)
1656 else if (p
[0] == '/' && p
[1] == '.'
1657 && (p
[2] == '/' || p
[2] == 0))
1659 else if (!strncmp (p
, "/..", 3)
1660 /* `/../' is the "superroot" on certain file systems. */
1662 && (p
[3] == '/' || p
[3] == 0))
1664 while (o
!= target
&& *--o
!= '/')
1666 if (o
== target
&& *o
== '/')
1676 return make_string (target
, o
- target
);
1680 /* If /~ or // appears, discard everything through first slash. */
1682 file_name_absolute_p (const char *filename
)
1685 (IS_DIRECTORY_SEP (*filename
) || *filename
== '~'
1687 || (IS_DRIVE (*filename
) && IS_DEVICE_SEP (filename
[1])
1688 && IS_DIRECTORY_SEP (filename
[2]))
1694 search_embedded_absfilename (char *nm
, char *endp
)
1698 for (p
= nm
+ 1; p
< endp
; p
++)
1700 if (IS_DIRECTORY_SEP (p
[-1])
1701 && file_name_absolute_p (p
)
1702 #if defined (WINDOWSNT) || defined (CYGWIN)
1703 /* // at start of file name is meaningful in Apollo,
1704 WindowsNT and Cygwin systems. */
1705 && !(IS_DIRECTORY_SEP (p
[0]) && p
- 1 == nm
)
1706 #endif /* not (WINDOWSNT || CYGWIN) */
1709 for (s
= p
; *s
&& !IS_DIRECTORY_SEP (*s
); s
++);
1710 if (p
[0] == '~' && s
> p
+ 1) /* We've got "/~something/". */
1712 char *o
= alloca (s
- p
+ 1);
1714 memcpy (o
, p
, s
- p
);
1717 /* If we have ~user and `user' exists, discard
1718 everything up to ~. But if `user' does not exist, leave
1719 ~user alone, it might be a literal file name. */
1721 pw
= getpwnam (o
+ 1);
1733 DEFUN ("substitute-in-file-name", Fsubstitute_in_file_name
,
1734 Ssubstitute_in_file_name
, 1, 1, 0,
1735 doc
: /* Substitute environment variables referred to in FILENAME.
1736 `$FOO' where FOO is an environment variable name means to substitute
1737 the value of that variable. The variable name should be terminated
1738 with a character not a letter, digit or underscore; otherwise, enclose
1739 the entire variable name in braces.
1741 If `/~' appears, all of FILENAME through that `/' is discarded.
1742 If `//' appears, everything up to and including the first of
1743 those `/' is discarded. */)
1744 (Lisp_Object filename
)
1746 char *nm
, *p
, *x
, *endp
;
1747 bool substituted
= false;
1750 Lisp_Object handler
;
1752 CHECK_STRING (filename
);
1754 multibyte
= STRING_MULTIBYTE (filename
);
1756 /* If the file name has special constructs in it,
1757 call the corresponding file handler. */
1758 handler
= Ffind_file_name_handler (filename
, Qsubstitute_in_file_name
);
1759 if (!NILP (handler
))
1761 Lisp_Object handled_name
= call2 (handler
, Qsubstitute_in_file_name
,
1763 if (STRINGP (handled_name
))
1764 return handled_name
;
1765 error ("Invalid handler in `file-name-handler-alist'");
1768 /* Always work on a copy of the string, in case GC happens during
1769 decode of environment variables, causing the original Lisp_String
1770 data to be relocated. */
1771 nm
= xlispstrdupa (filename
);
1774 /* FIXME: Figure out multibyte and downcase. */
1775 dostounix_filename (nm
);
1776 substituted
= (memcmp (nm
, SDATA (filename
), SBYTES (filename
)) != 0);
1778 endp
= nm
+ SBYTES (filename
);
1780 /* If /~ or // appears, discard everything through first slash. */
1781 p
= search_embedded_absfilename (nm
, endp
);
1783 /* Start over with the new string, so we check the file-name-handler
1784 again. Important with filenames like "/home/foo//:/hello///there"
1785 which would substitute to "/:/hello///there" rather than "/there". */
1786 return Fsubstitute_in_file_name
1787 (make_specified_string (p
, -1, endp
- p
, multibyte
));
1789 /* See if any variables are substituted into the string. */
1791 if (!NILP (Ffboundp (Qsubstitute_env_in_file_name
)))
1794 = (!substituted
? filename
1795 : make_specified_string (nm
, -1, endp
- nm
, multibyte
));
1796 Lisp_Object tmp
= call1 (Qsubstitute_env_in_file_name
, name
);
1798 if (!EQ (tmp
, name
))
1806 if (!NILP (Vw32_downcase_file_names
))
1807 filename
= Fdowncase (filename
);
1812 xnm
= SSDATA (filename
);
1813 x
= xnm
+ SBYTES (filename
);
1815 /* If /~ or // appears, discard everything through first slash. */
1816 while ((p
= search_embedded_absfilename (xnm
, x
)) != NULL
)
1817 /* This time we do not start over because we've already expanded envvars
1818 and replaced $$ with $. Maybe we should start over as well, but we'd
1819 need to quote some $ to $$ first. */
1823 if (!NILP (Vw32_downcase_file_names
))
1825 Lisp_Object xname
= make_specified_string (xnm
, -1, x
- xnm
, multibyte
);
1827 xname
= Fdowncase (xname
);
1832 return (xnm
== SSDATA (filename
)
1834 : make_specified_string (xnm
, -1, x
- xnm
, multibyte
));
1837 /* A slightly faster and more convenient way to get
1838 (directory-file-name (expand-file-name FOO)). */
1841 expand_and_dir_to_file (Lisp_Object filename
, Lisp_Object defdir
)
1843 register Lisp_Object absname
;
1845 absname
= Fexpand_file_name (filename
, defdir
);
1847 /* Remove final slash, if any (unless this is the root dir).
1848 stat behaves differently depending! */
1849 if (SCHARS (absname
) > 1
1850 && IS_DIRECTORY_SEP (SREF (absname
, SBYTES (absname
) - 1))
1851 && !IS_DEVICE_SEP (SREF (absname
, SBYTES (absname
) - 2)))
1852 /* We cannot take shortcuts; they might be wrong for magic file names. */
1853 absname
= Fdirectory_file_name (absname
);
1857 /* Signal an error if the file ABSNAME already exists.
1858 If INTERACTIVE, ask the user whether to proceed,
1859 and bypass the error if the user says to go ahead.
1860 QUERYSTRING is a name for the action that is being considered
1863 *STATPTR is used to store the stat information if the file exists.
1864 If the file does not exist, STATPTR->st_mode is set to 0.
1865 If STATPTR is null, we don't store into it.
1867 If QUICK, ask for y or n, not yes or no. */
1870 barf_or_query_if_file_exists (Lisp_Object absname
, const char *querystring
,
1871 bool interactive
, struct stat
*statptr
,
1874 Lisp_Object tem
, encoded_filename
;
1875 struct stat statbuf
;
1876 struct gcpro gcpro1
;
1878 encoded_filename
= ENCODE_FILE (absname
);
1880 /* `stat' is a good way to tell whether the file exists,
1881 regardless of what access permissions it has. */
1882 if (lstat (SSDATA (encoded_filename
), &statbuf
) >= 0)
1884 if (S_ISDIR (statbuf
.st_mode
))
1885 xsignal2 (Qfile_error
,
1886 build_string ("File is a directory"), absname
);
1889 xsignal2 (Qfile_already_exists
,
1890 build_string ("File already exists"), absname
);
1892 tem
= format2 ("File %s already exists; %s anyway? ",
1893 absname
, build_string (querystring
));
1895 tem
= call1 (intern ("y-or-n-p"), tem
);
1897 tem
= do_yes_or_no_p (tem
);
1900 xsignal2 (Qfile_already_exists
,
1901 build_string ("File already exists"), absname
);
1908 statptr
->st_mode
= 0;
1913 DEFUN ("copy-file", Fcopy_file
, Scopy_file
, 2, 6,
1914 "fCopy file: \nGCopy %s to file: \np\nP",
1915 doc
: /* Copy FILE to NEWNAME. Both args must be strings.
1916 If NEWNAME names a directory, copy FILE there.
1918 This function always sets the file modes of the output file to match
1921 The optional third argument OK-IF-ALREADY-EXISTS specifies what to do
1922 if file NEWNAME already exists. If OK-IF-ALREADY-EXISTS is nil, we
1923 signal a `file-already-exists' error without overwriting. If
1924 OK-IF-ALREADY-EXISTS is a number, we request confirmation from the user
1925 about overwriting; this is what happens in interactive use with M-x.
1926 Any other value for OK-IF-ALREADY-EXISTS means to overwrite the
1929 Fourth arg KEEP-TIME non-nil means give the output file the same
1930 last-modified time as the old one. (This works on only some systems.)
1932 A prefix arg makes KEEP-TIME non-nil.
1934 If PRESERVE-UID-GID is non-nil, we try to transfer the
1935 uid and gid of FILE to NEWNAME.
1937 If PRESERVE-EXTENDED-ATTRIBUTES is non-nil, we try to copy additional
1938 attributes of FILE to NEWNAME, such as its SELinux context and ACL
1939 entries (depending on how Emacs was built). */)
1940 (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
)
1944 char buf
[16 * 1024];
1945 struct stat st
, out_st
;
1946 Lisp_Object handler
;
1947 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1948 ptrdiff_t count
= SPECPDL_INDEX ();
1949 Lisp_Object encoded_file
, encoded_newname
;
1951 security_context_t con
;
1958 encoded_file
= encoded_newname
= Qnil
;
1959 GCPRO4 (file
, newname
, encoded_file
, encoded_newname
);
1960 CHECK_STRING (file
);
1961 CHECK_STRING (newname
);
1963 if (!NILP (Ffile_directory_p (newname
)))
1964 newname
= Fexpand_file_name (Ffile_name_nondirectory (file
), newname
);
1966 newname
= Fexpand_file_name (newname
, Qnil
);
1968 file
= Fexpand_file_name (file
, Qnil
);
1970 /* If the input file name has special constructs in it,
1971 call the corresponding file handler. */
1972 handler
= Ffind_file_name_handler (file
, Qcopy_file
);
1973 /* Likewise for output file name. */
1975 handler
= Ffind_file_name_handler (newname
, Qcopy_file
);
1976 if (!NILP (handler
))
1977 RETURN_UNGCPRO (call7 (handler
, Qcopy_file
, file
, newname
,
1978 ok_if_already_exists
, keep_time
, preserve_uid_gid
,
1979 preserve_extended_attributes
));
1981 encoded_file
= ENCODE_FILE (file
);
1982 encoded_newname
= ENCODE_FILE (newname
);
1984 if (NILP (ok_if_already_exists
)
1985 || INTEGERP (ok_if_already_exists
))
1986 barf_or_query_if_file_exists (newname
, "copy to it",
1987 INTEGERP (ok_if_already_exists
), &out_st
, 0);
1988 else if (stat (SSDATA (encoded_newname
), &out_st
) < 0)
1992 if (!NILP (preserve_extended_attributes
))
1994 acl
= acl_get_file (SDATA (encoded_file
), ACL_TYPE_ACCESS
);
1995 if (acl
== NULL
&& acl_errno_valid (errno
))
1996 report_file_error ("Getting ACL", file
);
1998 if (!CopyFile (SDATA (encoded_file
),
1999 SDATA (encoded_newname
),
2002 /* CopyFile doesn't set errno when it fails. By far the most
2003 "popular" reason is that the target is read-only. */
2004 report_file_errno ("Copying file", list2 (file
, newname
),
2005 GetLastError () == 5 ? EACCES
: EPERM
);
2007 /* CopyFile retains the timestamp by default. */
2008 else if (NILP (keep_time
))
2010 struct timespec now
;
2014 filename
= SDATA (encoded_newname
);
2016 /* Ensure file is writable while its modified time is set. */
2017 attributes
= GetFileAttributes (filename
);
2018 SetFileAttributes (filename
, attributes
& ~FILE_ATTRIBUTE_READONLY
);
2019 now
= current_timespec ();
2020 if (set_file_times (-1, filename
, now
, now
))
2022 /* Restore original attributes. */
2023 SetFileAttributes (filename
, attributes
);
2024 xsignal2 (Qfile_date_error
,
2025 build_string ("Cannot set file date"), newname
);
2027 /* Restore original attributes. */
2028 SetFileAttributes (filename
, attributes
);
2033 acl_set_file (SDATA (encoded_newname
), ACL_TYPE_ACCESS
, acl
) != 0;
2034 if (fail
&& acl_errno_valid (errno
))
2035 report_file_error ("Setting ACL", newname
);
2039 #else /* not WINDOWSNT */
2041 ifd
= emacs_open (SSDATA (encoded_file
), O_RDONLY
, 0);
2045 report_file_error ("Opening input file", file
);
2047 record_unwind_protect_int (close_file_unwind
, ifd
);
2049 if (fstat (ifd
, &st
) != 0)
2050 report_file_error ("Input file status", file
);
2052 if (!NILP (preserve_extended_attributes
))
2055 if (is_selinux_enabled ())
2057 conlength
= fgetfilecon (ifd
, &con
);
2058 if (conlength
== -1)
2059 report_file_error ("Doing fgetfilecon", file
);
2064 if (out_st
.st_mode
!= 0
2065 && st
.st_dev
== out_st
.st_dev
&& st
.st_ino
== out_st
.st_ino
)
2066 report_file_errno ("Input and output files are the same",
2067 list2 (file
, newname
), 0);
2069 /* We can copy only regular files. */
2070 if (!S_ISREG (st
.st_mode
))
2071 report_file_errno ("Non-regular file", file
,
2072 S_ISDIR (st
.st_mode
) ? EISDIR
: EINVAL
);
2076 int new_mask
= st
.st_mode
& (!NILP (preserve_uid_gid
) ? 0600 : 0666);
2078 int new_mask
= S_IREAD
| S_IWRITE
;
2080 ofd
= emacs_open (SSDATA (encoded_newname
),
2081 (O_WRONLY
| O_TRUNC
| O_CREAT
2082 | (NILP (ok_if_already_exists
) ? O_EXCL
: 0)),
2086 report_file_error ("Opening output file", newname
);
2088 record_unwind_protect_int (close_file_unwind
, ofd
);
2092 while ((n
= emacs_read (ifd
, buf
, sizeof buf
)) > 0)
2093 if (emacs_write_sig (ofd
, buf
, n
) != n
)
2094 report_file_error ("Write error", newname
);
2098 /* Preserve the original file permissions, and if requested, also its
2101 mode_t mode_mask
= 07777;
2102 if (!NILP (preserve_uid_gid
))
2104 /* Attempt to change owner and group. If that doesn't work
2105 attempt to change just the group, as that is sometimes allowed.
2106 Adjust the mode mask to eliminate setuid or setgid bits
2107 that are inappropriate if the owner and group are wrong. */
2108 if (fchown (ofd
, st
.st_uid
, st
.st_gid
) != 0)
2110 mode_mask
&= ~06000;
2111 if (fchown (ofd
, -1, st
.st_gid
) == 0)
2116 switch (!NILP (preserve_extended_attributes
)
2117 ? qcopy_acl (SSDATA (encoded_file
), ifd
,
2118 SSDATA (encoded_newname
), ofd
,
2119 st
.st_mode
& mode_mask
)
2120 : fchmod (ofd
, st
.st_mode
& mode_mask
))
2122 case -2: report_file_error ("Copying permissions from", file
);
2123 case -1: report_file_error ("Copying permissions to", newname
);
2126 #endif /* not MSDOS */
2131 /* Set the modified context back to the file. */
2132 bool fail
= fsetfilecon (ofd
, con
) != 0;
2133 /* See http://debbugs.gnu.org/11245 for ENOTSUP. */
2134 if (fail
&& errno
!= ENOTSUP
)
2135 report_file_error ("Doing fsetfilecon", newname
);
2141 if (!NILP (keep_time
))
2143 struct timespec atime
= get_stat_atime (&st
);
2144 struct timespec mtime
= get_stat_mtime (&st
);
2145 if (set_file_times (ofd
, SSDATA (encoded_newname
), atime
, mtime
))
2146 xsignal2 (Qfile_date_error
,
2147 build_string ("Cannot set file date"), newname
);
2150 if (emacs_close (ofd
) < 0)
2151 report_file_error ("Write error", newname
);
2156 /* In DJGPP v2.0 and later, fstat usually returns true file mode bits,
2157 and if it can't, it tells so. Otherwise, under MSDOS we usually
2158 get only the READ bit, which will make the copied file read-only,
2159 so it's better not to chmod at all. */
2160 if ((_djstat_flags
& _STFAIL_WRITEBIT
) == 0)
2161 chmod (SDATA (encoded_newname
), st
.st_mode
& 07777);
2163 #endif /* not WINDOWSNT */
2165 /* Discard the unwind protects. */
2166 specpdl_ptr
= specpdl
+ count
;
2172 DEFUN ("make-directory-internal", Fmake_directory_internal
,
2173 Smake_directory_internal
, 1, 1, 0,
2174 doc
: /* Create a new directory named DIRECTORY. */)
2175 (Lisp_Object directory
)
2178 Lisp_Object handler
;
2179 Lisp_Object encoded_dir
;
2181 CHECK_STRING (directory
);
2182 directory
= Fexpand_file_name (directory
, Qnil
);
2184 handler
= Ffind_file_name_handler (directory
, Qmake_directory_internal
);
2185 if (!NILP (handler
))
2186 return call2 (handler
, Qmake_directory_internal
, directory
);
2188 encoded_dir
= ENCODE_FILE (directory
);
2190 dir
= SSDATA (encoded_dir
);
2193 if (mkdir (dir
) != 0)
2195 if (mkdir (dir
, 0777 & ~auto_saving_dir_umask
) != 0)
2197 report_file_error ("Creating directory", directory
);
2202 DEFUN ("delete-directory-internal", Fdelete_directory_internal
,
2203 Sdelete_directory_internal
, 1, 1, 0,
2204 doc
: /* Delete the directory named DIRECTORY. Does not follow symlinks. */)
2205 (Lisp_Object directory
)
2208 Lisp_Object encoded_dir
;
2210 CHECK_STRING (directory
);
2211 directory
= Fdirectory_file_name (Fexpand_file_name (directory
, Qnil
));
2212 encoded_dir
= ENCODE_FILE (directory
);
2213 dir
= SSDATA (encoded_dir
);
2215 if (rmdir (dir
) != 0)
2216 report_file_error ("Removing directory", directory
);
2221 DEFUN ("delete-file", Fdelete_file
, Sdelete_file
, 1, 2,
2222 "(list (read-file-name \
2223 (if (and delete-by-moving-to-trash (null current-prefix-arg)) \
2224 \"Move file to trash: \" \"Delete file: \") \
2225 nil default-directory (confirm-nonexistent-file-or-buffer)) \
2226 (null current-prefix-arg))",
2227 doc
: /* Delete file named FILENAME. If it is a symlink, remove the symlink.
2228 If file has multiple names, it continues to exist with the other names.
2229 TRASH non-nil means to trash the file instead of deleting, provided
2230 `delete-by-moving-to-trash' is non-nil.
2232 When called interactively, TRASH is t if no prefix argument is given.
2233 With a prefix argument, TRASH is nil. */)
2234 (Lisp_Object filename
, Lisp_Object trash
)
2236 Lisp_Object handler
;
2237 Lisp_Object encoded_file
;
2238 struct gcpro gcpro1
;
2241 if (!NILP (Ffile_directory_p (filename
))
2242 && NILP (Ffile_symlink_p (filename
)))
2243 xsignal2 (Qfile_error
,
2244 build_string ("Removing old name: is a directory"),
2247 filename
= Fexpand_file_name (filename
, Qnil
);
2249 handler
= Ffind_file_name_handler (filename
, Qdelete_file
);
2250 if (!NILP (handler
))
2251 return call3 (handler
, Qdelete_file
, filename
, trash
);
2253 if (delete_by_moving_to_trash
&& !NILP (trash
))
2254 return call1 (Qmove_file_to_trash
, filename
);
2256 encoded_file
= ENCODE_FILE (filename
);
2258 if (unlink (SSDATA (encoded_file
)) < 0)
2259 report_file_error ("Removing old name", filename
);
2264 internal_delete_file_1 (Lisp_Object ignore
)
2269 /* Delete file FILENAME, returning true if successful.
2270 This ignores `delete-by-moving-to-trash'. */
2273 internal_delete_file (Lisp_Object filename
)
2277 tem
= internal_condition_case_2 (Fdelete_file
, filename
, Qnil
,
2278 Qt
, internal_delete_file_1
);
2282 DEFUN ("rename-file", Frename_file
, Srename_file
, 2, 3,
2283 "fRename file: \nGRename %s to file: \np",
2284 doc
: /* Rename FILE as NEWNAME. Both args must be strings.
2285 If file has names other than FILE, it continues to have those names.
2286 Signals a `file-already-exists' error if a file NEWNAME already exists
2287 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
2288 A number as third arg means request confirmation if NEWNAME already exists.
2289 This is what happens in interactive use with M-x. */)
2290 (Lisp_Object file
, Lisp_Object newname
, Lisp_Object ok_if_already_exists
)
2292 Lisp_Object handler
;
2293 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2294 Lisp_Object encoded_file
, encoded_newname
, symlink_target
;
2296 symlink_target
= encoded_file
= encoded_newname
= Qnil
;
2297 GCPRO5 (file
, newname
, encoded_file
, encoded_newname
, symlink_target
);
2298 CHECK_STRING (file
);
2299 CHECK_STRING (newname
);
2300 file
= Fexpand_file_name (file
, Qnil
);
2302 if ((!NILP (Ffile_directory_p (newname
)))
2304 /* If the file names are identical but for the case,
2305 don't attempt to move directory to itself. */
2306 && (NILP (Fstring_equal (Fdowncase (file
), Fdowncase (newname
))))
2310 Lisp_Object fname
= (NILP (Ffile_directory_p (file
))
2311 ? file
: Fdirectory_file_name (file
));
2312 newname
= Fexpand_file_name (Ffile_name_nondirectory (fname
), newname
);
2315 newname
= Fexpand_file_name (newname
, Qnil
);
2317 /* If the file name has special constructs in it,
2318 call the corresponding file handler. */
2319 handler
= Ffind_file_name_handler (file
, Qrename_file
);
2321 handler
= Ffind_file_name_handler (newname
, Qrename_file
);
2322 if (!NILP (handler
))
2323 RETURN_UNGCPRO (call4 (handler
, Qrename_file
,
2324 file
, newname
, ok_if_already_exists
));
2326 encoded_file
= ENCODE_FILE (file
);
2327 encoded_newname
= ENCODE_FILE (newname
);
2330 /* If the file names are identical but for the case, don't ask for
2331 confirmation: they simply want to change the letter-case of the
2333 if (NILP (Fstring_equal (Fdowncase (file
), Fdowncase (newname
))))
2335 if (NILP (ok_if_already_exists
)
2336 || INTEGERP (ok_if_already_exists
))
2337 barf_or_query_if_file_exists (newname
, "rename to it",
2338 INTEGERP (ok_if_already_exists
), 0, 0);
2339 if (rename (SSDATA (encoded_file
), SSDATA (encoded_newname
)) < 0)
2341 int rename_errno
= errno
;
2342 if (rename_errno
== EXDEV
)
2345 symlink_target
= Ffile_symlink_p (file
);
2346 if (! NILP (symlink_target
))
2347 Fmake_symbolic_link (symlink_target
, newname
,
2348 NILP (ok_if_already_exists
) ? Qnil
: Qt
);
2349 else if (!NILP (Ffile_directory_p (file
)))
2350 call4 (Qcopy_directory
, file
, newname
, Qt
, Qnil
);
2352 /* We have already prompted if it was an integer, so don't
2353 have copy-file prompt again. */
2354 Fcopy_file (file
, newname
,
2355 NILP (ok_if_already_exists
) ? Qnil
: Qt
,
2358 count
= SPECPDL_INDEX ();
2359 specbind (Qdelete_by_moving_to_trash
, Qnil
);
2361 if (!NILP (Ffile_directory_p (file
)) && NILP (symlink_target
))
2362 call2 (Qdelete_directory
, file
, Qt
);
2364 Fdelete_file (file
, Qnil
);
2365 unbind_to (count
, Qnil
);
2368 report_file_errno ("Renaming", list2 (file
, newname
), rename_errno
);
2374 DEFUN ("add-name-to-file", Fadd_name_to_file
, Sadd_name_to_file
, 2, 3,
2375 "fAdd name to file: \nGName to add to %s: \np",
2376 doc
: /* Give FILE additional name NEWNAME. Both args must be strings.
2377 Signals a `file-already-exists' error if a file NEWNAME already exists
2378 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
2379 A number as third arg means request confirmation if NEWNAME already exists.
2380 This is what happens in interactive use with M-x. */)
2381 (Lisp_Object file
, Lisp_Object newname
, Lisp_Object ok_if_already_exists
)
2383 Lisp_Object handler
;
2384 Lisp_Object encoded_file
, encoded_newname
;
2385 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2387 GCPRO4 (file
, newname
, encoded_file
, encoded_newname
);
2388 encoded_file
= encoded_newname
= Qnil
;
2389 CHECK_STRING (file
);
2390 CHECK_STRING (newname
);
2391 file
= Fexpand_file_name (file
, Qnil
);
2393 if (!NILP (Ffile_directory_p (newname
)))
2394 newname
= Fexpand_file_name (Ffile_name_nondirectory (file
), newname
);
2396 newname
= Fexpand_file_name (newname
, Qnil
);
2398 /* If the file name has special constructs in it,
2399 call the corresponding file handler. */
2400 handler
= Ffind_file_name_handler (file
, Qadd_name_to_file
);
2401 if (!NILP (handler
))
2402 RETURN_UNGCPRO (call4 (handler
, Qadd_name_to_file
, file
,
2403 newname
, ok_if_already_exists
));
2405 /* If the new name has special constructs in it,
2406 call the corresponding file handler. */
2407 handler
= Ffind_file_name_handler (newname
, Qadd_name_to_file
);
2408 if (!NILP (handler
))
2409 RETURN_UNGCPRO (call4 (handler
, Qadd_name_to_file
, file
,
2410 newname
, ok_if_already_exists
));
2412 encoded_file
= ENCODE_FILE (file
);
2413 encoded_newname
= ENCODE_FILE (newname
);
2415 if (NILP (ok_if_already_exists
)
2416 || INTEGERP (ok_if_already_exists
))
2417 barf_or_query_if_file_exists (newname
, "make it a new name",
2418 INTEGERP (ok_if_already_exists
), 0, 0);
2420 unlink (SSDATA (newname
));
2421 if (link (SSDATA (encoded_file
), SSDATA (encoded_newname
)) < 0)
2423 int link_errno
= errno
;
2424 report_file_errno ("Adding new name", list2 (file
, newname
), link_errno
);
2431 DEFUN ("make-symbolic-link", Fmake_symbolic_link
, Smake_symbolic_link
, 2, 3,
2432 "FMake symbolic link to file: \nGMake symbolic link to file %s: \np",
2433 doc
: /* Make a symbolic link to FILENAME, named LINKNAME.
2434 Both args must be strings.
2435 Signals a `file-already-exists' error if a file LINKNAME already exists
2436 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
2437 A number as third arg means request confirmation if LINKNAME already exists.
2438 This happens for interactive use with M-x. */)
2439 (Lisp_Object filename
, Lisp_Object linkname
, Lisp_Object ok_if_already_exists
)
2441 Lisp_Object handler
;
2442 Lisp_Object encoded_filename
, encoded_linkname
;
2443 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2445 GCPRO4 (filename
, linkname
, encoded_filename
, encoded_linkname
);
2446 encoded_filename
= encoded_linkname
= Qnil
;
2447 CHECK_STRING (filename
);
2448 CHECK_STRING (linkname
);
2449 /* If the link target has a ~, we must expand it to get
2450 a truly valid file name. Otherwise, do not expand;
2451 we want to permit links to relative file names. */
2452 if (SREF (filename
, 0) == '~')
2453 filename
= Fexpand_file_name (filename
, Qnil
);
2455 if (!NILP (Ffile_directory_p (linkname
)))
2456 linkname
= Fexpand_file_name (Ffile_name_nondirectory (filename
), linkname
);
2458 linkname
= Fexpand_file_name (linkname
, Qnil
);
2460 /* If the file name has special constructs in it,
2461 call the corresponding file handler. */
2462 handler
= Ffind_file_name_handler (filename
, Qmake_symbolic_link
);
2463 if (!NILP (handler
))
2464 RETURN_UNGCPRO (call4 (handler
, Qmake_symbolic_link
, filename
,
2465 linkname
, ok_if_already_exists
));
2467 /* If the new link name has special constructs in it,
2468 call the corresponding file handler. */
2469 handler
= Ffind_file_name_handler (linkname
, Qmake_symbolic_link
);
2470 if (!NILP (handler
))
2471 RETURN_UNGCPRO (call4 (handler
, Qmake_symbolic_link
, filename
,
2472 linkname
, ok_if_already_exists
));
2474 encoded_filename
= ENCODE_FILE (filename
);
2475 encoded_linkname
= ENCODE_FILE (linkname
);
2477 if (NILP (ok_if_already_exists
)
2478 || INTEGERP (ok_if_already_exists
))
2479 barf_or_query_if_file_exists (linkname
, "make it a link",
2480 INTEGERP (ok_if_already_exists
), 0, 0);
2481 if (symlink (SSDATA (encoded_filename
), SSDATA (encoded_linkname
)) < 0)
2483 /* If we didn't complain already, silently delete existing file. */
2485 if (errno
== EEXIST
)
2487 unlink (SSDATA (encoded_linkname
));
2488 if (symlink (SSDATA (encoded_filename
), SSDATA (encoded_linkname
))
2495 if (errno
== ENOSYS
)
2498 xsignal1 (Qfile_error
,
2499 build_string ("Symbolic links are not supported"));
2502 symlink_errno
= errno
;
2503 report_file_errno ("Making symbolic link", list2 (filename
, linkname
),
2511 DEFUN ("file-name-absolute-p", Ffile_name_absolute_p
, Sfile_name_absolute_p
,
2513 doc
: /* Return t if file FILENAME specifies an absolute file name.
2514 On Unix, this is a name starting with a `/' or a `~'. */)
2515 (Lisp_Object filename
)
2517 CHECK_STRING (filename
);
2518 return file_name_absolute_p (SSDATA (filename
)) ? Qt
: Qnil
;
2521 DEFUN ("file-exists-p", Ffile_exists_p
, Sfile_exists_p
, 1, 1, 0,
2522 doc
: /* Return t if file FILENAME exists (whether or not you can read it.)
2523 See also `file-readable-p' and `file-attributes'.
2524 This returns nil for a symlink to a nonexistent file.
2525 Use `file-symlink-p' to test for such links. */)
2526 (Lisp_Object filename
)
2528 Lisp_Object absname
;
2529 Lisp_Object handler
;
2531 CHECK_STRING (filename
);
2532 absname
= Fexpand_file_name (filename
, Qnil
);
2534 /* If the file name has special constructs in it,
2535 call the corresponding file handler. */
2536 handler
= Ffind_file_name_handler (absname
, Qfile_exists_p
);
2537 if (!NILP (handler
))
2539 Lisp_Object result
= call2 (handler
, Qfile_exists_p
, absname
);
2544 absname
= ENCODE_FILE (absname
);
2546 return check_existing (SSDATA (absname
)) ? Qt
: Qnil
;
2549 DEFUN ("file-executable-p", Ffile_executable_p
, Sfile_executable_p
, 1, 1, 0,
2550 doc
: /* Return t if FILENAME can be executed by you.
2551 For a directory, this means you can access files in that directory. */)
2552 (Lisp_Object filename
)
2554 Lisp_Object absname
;
2555 Lisp_Object handler
;
2557 CHECK_STRING (filename
);
2558 absname
= Fexpand_file_name (filename
, Qnil
);
2560 /* If the file name has special constructs in it,
2561 call the corresponding file handler. */
2562 handler
= Ffind_file_name_handler (absname
, Qfile_executable_p
);
2563 if (!NILP (handler
))
2564 return call2 (handler
, Qfile_executable_p
, absname
);
2566 absname
= ENCODE_FILE (absname
);
2568 return (check_executable (SSDATA (absname
)) ? Qt
: Qnil
);
2571 DEFUN ("file-readable-p", Ffile_readable_p
, Sfile_readable_p
, 1, 1, 0,
2572 doc
: /* Return t if file FILENAME exists and you can read it.
2573 See also `file-exists-p' and `file-attributes'. */)
2574 (Lisp_Object filename
)
2576 Lisp_Object absname
;
2577 Lisp_Object handler
;
2579 CHECK_STRING (filename
);
2580 absname
= Fexpand_file_name (filename
, Qnil
);
2582 /* If the file name has special constructs in it,
2583 call the corresponding file handler. */
2584 handler
= Ffind_file_name_handler (absname
, Qfile_readable_p
);
2585 if (!NILP (handler
))
2586 return call2 (handler
, Qfile_readable_p
, absname
);
2588 absname
= ENCODE_FILE (absname
);
2589 return (faccessat (AT_FDCWD
, SSDATA (absname
), R_OK
, AT_EACCESS
) == 0
2593 DEFUN ("file-writable-p", Ffile_writable_p
, Sfile_writable_p
, 1, 1, 0,
2594 doc
: /* Return t if file FILENAME can be written or created by you. */)
2595 (Lisp_Object filename
)
2597 Lisp_Object absname
, dir
, encoded
;
2598 Lisp_Object handler
;
2600 CHECK_STRING (filename
);
2601 absname
= Fexpand_file_name (filename
, Qnil
);
2603 /* If the file name has special constructs in it,
2604 call the corresponding file handler. */
2605 handler
= Ffind_file_name_handler (absname
, Qfile_writable_p
);
2606 if (!NILP (handler
))
2607 return call2 (handler
, Qfile_writable_p
, absname
);
2609 encoded
= ENCODE_FILE (absname
);
2610 if (check_writable (SSDATA (encoded
), W_OK
))
2612 if (errno
!= ENOENT
)
2615 dir
= Ffile_name_directory (absname
);
2616 eassert (!NILP (dir
));
2618 dir
= Fdirectory_file_name (dir
);
2621 dir
= ENCODE_FILE (dir
);
2623 /* The read-only attribute of the parent directory doesn't affect
2624 whether a file or directory can be created within it. Some day we
2625 should check ACLs though, which do affect this. */
2626 return file_directory_p (SDATA (dir
)) ? Qt
: Qnil
;
2628 return check_writable (SSDATA (dir
), W_OK
| X_OK
) ? Qt
: Qnil
;
2632 DEFUN ("access-file", Faccess_file
, Saccess_file
, 2, 2, 0,
2633 doc
: /* Access file FILENAME, and get an error if that does not work.
2634 The second argument STRING is used in the error message.
2635 If there is no error, returns nil. */)
2636 (Lisp_Object filename
, Lisp_Object string
)
2638 Lisp_Object handler
, encoded_filename
, absname
;
2640 CHECK_STRING (filename
);
2641 absname
= Fexpand_file_name (filename
, Qnil
);
2643 CHECK_STRING (string
);
2645 /* If the file name has special constructs in it,
2646 call the corresponding file handler. */
2647 handler
= Ffind_file_name_handler (absname
, Qaccess_file
);
2648 if (!NILP (handler
))
2649 return call3 (handler
, Qaccess_file
, absname
, string
);
2651 encoded_filename
= ENCODE_FILE (absname
);
2653 if (faccessat (AT_FDCWD
, SSDATA (encoded_filename
), R_OK
, AT_EACCESS
) != 0)
2654 report_file_error (SSDATA (string
), filename
);
2659 /* Relative to directory FD, return the symbolic link value of FILENAME.
2660 On failure, return nil. */
2662 emacs_readlinkat (int fd
, char const *filename
)
2664 static struct allocator
const emacs_norealloc_allocator
=
2665 { xmalloc
, NULL
, xfree
, memory_full
};
2667 char readlink_buf
[1024];
2668 char *buf
= careadlinkat (fd
, filename
, readlink_buf
, sizeof readlink_buf
,
2669 &emacs_norealloc_allocator
, readlinkat
);
2673 val
= build_string (buf
);
2674 if (buf
[0] == '/' && strchr (buf
, ':'))
2675 val
= concat2 (build_string ("/:"), val
);
2676 if (buf
!= readlink_buf
)
2678 val
= DECODE_FILE (val
);
2682 DEFUN ("file-symlink-p", Ffile_symlink_p
, Sfile_symlink_p
, 1, 1, 0,
2683 doc
: /* Return non-nil if file FILENAME is the name of a symbolic link.
2684 The value is the link target, as a string.
2685 Otherwise it returns nil.
2687 This function returns t when given the name of a symlink that
2688 points to a nonexistent file. */)
2689 (Lisp_Object filename
)
2691 Lisp_Object handler
;
2693 CHECK_STRING (filename
);
2694 filename
= Fexpand_file_name (filename
, Qnil
);
2696 /* If the file name has special constructs in it,
2697 call the corresponding file handler. */
2698 handler
= Ffind_file_name_handler (filename
, Qfile_symlink_p
);
2699 if (!NILP (handler
))
2700 return call2 (handler
, Qfile_symlink_p
, filename
);
2702 filename
= ENCODE_FILE (filename
);
2704 return emacs_readlinkat (AT_FDCWD
, SSDATA (filename
));
2707 DEFUN ("file-directory-p", Ffile_directory_p
, Sfile_directory_p
, 1, 1, 0,
2708 doc
: /* Return t if FILENAME names an existing directory.
2709 Symbolic links to directories count as directories.
2710 See `file-symlink-p' to distinguish symlinks. */)
2711 (Lisp_Object filename
)
2713 Lisp_Object absname
;
2714 Lisp_Object handler
;
2716 absname
= expand_and_dir_to_file (filename
, BVAR (current_buffer
, directory
));
2718 /* If the file name has special constructs in it,
2719 call the corresponding file handler. */
2720 handler
= Ffind_file_name_handler (absname
, Qfile_directory_p
);
2721 if (!NILP (handler
))
2722 return call2 (handler
, Qfile_directory_p
, absname
);
2724 absname
= ENCODE_FILE (absname
);
2726 return file_directory_p (SSDATA (absname
)) ? Qt
: Qnil
;
2729 /* Return true if FILE is a directory or a symlink to a directory. */
2731 file_directory_p (char const *file
)
2734 /* This is cheaper than 'stat'. */
2735 return faccessat (AT_FDCWD
, file
, D_OK
, AT_EACCESS
) == 0;
2738 return stat (file
, &st
) == 0 && S_ISDIR (st
.st_mode
);
2742 DEFUN ("file-accessible-directory-p", Ffile_accessible_directory_p
,
2743 Sfile_accessible_directory_p
, 1, 1, 0,
2744 doc
: /* Return t if file FILENAME names a directory you can open.
2745 For the value to be t, FILENAME must specify the name of a directory as a file,
2746 and the directory must allow you to open files in it. In order to use a
2747 directory as a buffer's current directory, this predicate must return true.
2748 A directory name spec may be given instead; then the value is t
2749 if the directory so specified exists and really is a readable and
2750 searchable directory. */)
2751 (Lisp_Object filename
)
2753 Lisp_Object absname
;
2754 Lisp_Object handler
;
2756 CHECK_STRING (filename
);
2757 absname
= Fexpand_file_name (filename
, Qnil
);
2759 /* If the file name has special constructs in it,
2760 call the corresponding file handler. */
2761 handler
= Ffind_file_name_handler (absname
, Qfile_accessible_directory_p
);
2762 if (!NILP (handler
))
2764 Lisp_Object r
= call2 (handler
, Qfile_accessible_directory_p
, absname
);
2769 absname
= ENCODE_FILE (absname
);
2770 return file_accessible_directory_p (SSDATA (absname
)) ? Qt
: Qnil
;
2773 /* If FILE is a searchable directory or a symlink to a
2774 searchable directory, return true. Otherwise return
2775 false and set errno to an error number. */
2777 file_accessible_directory_p (char const *file
)
2780 /* There's no need to test whether FILE is searchable, as the
2781 searchable/executable bit is invented on DOS_NT platforms. */
2782 return file_directory_p (file
);
2784 /* On POSIXish platforms, use just one system call; this avoids a
2785 race and is typically faster. */
2786 ptrdiff_t len
= strlen (file
);
2792 /* Normally a file "FOO" is an accessible directory if "FOO/." exists.
2793 There are three exceptions: "", "/", and "//". Leave "" alone,
2794 as it's invalid. Append only "." to the other two exceptions as
2795 "/" and "//" are distinct on some platforms, whereas "/", "///",
2796 "////", etc. are all equivalent. */
2801 /* Just check for trailing '/' when deciding whether to append '/'.
2802 That's simpler than testing the two special cases "/" and "//",
2803 and it's a safe optimization here. */
2804 char *buf
= SAFE_ALLOCA (len
+ 3);
2805 memcpy (buf
, file
, len
);
2806 strcpy (buf
+ len
, &"/."[file
[len
- 1] == '/']);
2810 ok
= check_existing (dir
);
2811 saved_errno
= errno
;
2813 errno
= saved_errno
;
2818 DEFUN ("file-regular-p", Ffile_regular_p
, Sfile_regular_p
, 1, 1, 0,
2819 doc
: /* Return t if FILENAME names a regular file.
2820 This is the sort of file that holds an ordinary stream of data bytes.
2821 Symbolic links to regular files count as regular files.
2822 See `file-symlink-p' to distinguish symlinks. */)
2823 (Lisp_Object filename
)
2825 register Lisp_Object absname
;
2827 Lisp_Object handler
;
2829 absname
= expand_and_dir_to_file (filename
, BVAR (current_buffer
, directory
));
2831 /* If the file name has special constructs in it,
2832 call the corresponding file handler. */
2833 handler
= Ffind_file_name_handler (absname
, Qfile_regular_p
);
2834 if (!NILP (handler
))
2835 return call2 (handler
, Qfile_regular_p
, absname
);
2837 absname
= ENCODE_FILE (absname
);
2842 Lisp_Object tem
= Vw32_get_true_file_attributes
;
2844 /* Tell stat to use expensive method to get accurate info. */
2845 Vw32_get_true_file_attributes
= Qt
;
2846 result
= stat (SDATA (absname
), &st
);
2847 Vw32_get_true_file_attributes
= tem
;
2851 return S_ISREG (st
.st_mode
) ? Qt
: Qnil
;
2854 if (stat (SSDATA (absname
), &st
) < 0)
2856 return S_ISREG (st
.st_mode
) ? Qt
: Qnil
;
2860 DEFUN ("file-selinux-context", Ffile_selinux_context
,
2861 Sfile_selinux_context
, 1, 1, 0,
2862 doc
: /* Return SELinux context of file named FILENAME.
2863 The return value is a list (USER ROLE TYPE RANGE), where the list
2864 elements are strings naming the user, role, type, and range of the
2865 file's SELinux security context.
2867 Return (nil nil nil nil) if the file is nonexistent or inaccessible,
2868 or if SELinux is disabled, or if Emacs lacks SELinux support. */)
2869 (Lisp_Object filename
)
2871 Lisp_Object absname
;
2872 Lisp_Object values
[4];
2873 Lisp_Object handler
;
2875 security_context_t con
;
2880 absname
= expand_and_dir_to_file (filename
, BVAR (current_buffer
, directory
));
2882 /* If the file name has special constructs in it,
2883 call the corresponding file handler. */
2884 handler
= Ffind_file_name_handler (absname
, Qfile_selinux_context
);
2885 if (!NILP (handler
))
2886 return call2 (handler
, Qfile_selinux_context
, absname
);
2888 absname
= ENCODE_FILE (absname
);
2895 if (is_selinux_enabled ())
2897 conlength
= lgetfilecon (SSDATA (absname
), &con
);
2900 context
= context_new (con
);
2901 if (context_user_get (context
))
2902 values
[0] = build_string (context_user_get (context
));
2903 if (context_role_get (context
))
2904 values
[1] = build_string (context_role_get (context
));
2905 if (context_type_get (context
))
2906 values
[2] = build_string (context_type_get (context
));
2907 if (context_range_get (context
))
2908 values
[3] = build_string (context_range_get (context
));
2909 context_free (context
);
2915 return Flist (sizeof (values
) / sizeof (values
[0]), values
);
2918 DEFUN ("set-file-selinux-context", Fset_file_selinux_context
,
2919 Sset_file_selinux_context
, 2, 2, 0,
2920 doc
: /* Set SELinux context of file named FILENAME to CONTEXT.
2921 CONTEXT should be a list (USER ROLE TYPE RANGE), where the list
2922 elements are strings naming the components of a SELinux context.
2924 Value is t if setting of SELinux context was successful, nil otherwise.
2926 This function does nothing and returns nil if SELinux is disabled,
2927 or if Emacs was not compiled with SELinux support. */)
2928 (Lisp_Object filename
, Lisp_Object context
)
2930 Lisp_Object absname
;
2931 Lisp_Object handler
;
2933 Lisp_Object encoded_absname
;
2934 Lisp_Object user
= CAR_SAFE (context
);
2935 Lisp_Object role
= CAR_SAFE (CDR_SAFE (context
));
2936 Lisp_Object type
= CAR_SAFE (CDR_SAFE (CDR_SAFE (context
)));
2937 Lisp_Object range
= CAR_SAFE (CDR_SAFE (CDR_SAFE (CDR_SAFE (context
))));
2938 security_context_t con
;
2941 context_t parsed_con
;
2944 absname
= Fexpand_file_name (filename
, BVAR (current_buffer
, directory
));
2946 /* If the file name has special constructs in it,
2947 call the corresponding file handler. */
2948 handler
= Ffind_file_name_handler (absname
, Qset_file_selinux_context
);
2949 if (!NILP (handler
))
2950 return call3 (handler
, Qset_file_selinux_context
, absname
, context
);
2953 if (is_selinux_enabled ())
2955 /* Get current file context. */
2956 encoded_absname
= ENCODE_FILE (absname
);
2957 conlength
= lgetfilecon (SSDATA (encoded_absname
), &con
);
2960 parsed_con
= context_new (con
);
2961 /* Change the parts defined in the parameter.*/
2964 if (context_user_set (parsed_con
, SSDATA (user
)))
2965 error ("Doing context_user_set");
2969 if (context_role_set (parsed_con
, SSDATA (role
)))
2970 error ("Doing context_role_set");
2974 if (context_type_set (parsed_con
, SSDATA (type
)))
2975 error ("Doing context_type_set");
2977 if (STRINGP (range
))
2979 if (context_range_set (parsed_con
, SSDATA (range
)))
2980 error ("Doing context_range_set");
2983 /* Set the modified context back to the file. */
2984 fail
= (lsetfilecon (SSDATA (encoded_absname
),
2985 context_str (parsed_con
))
2987 /* See http://debbugs.gnu.org/11245 for ENOTSUP. */
2988 if (fail
&& errno
!= ENOTSUP
)
2989 report_file_error ("Doing lsetfilecon", absname
);
2991 context_free (parsed_con
);
2993 return fail
? Qnil
: Qt
;
2996 report_file_error ("Doing lgetfilecon", absname
);
3003 DEFUN ("file-acl", Ffile_acl
, Sfile_acl
, 1, 1, 0,
3004 doc
: /* Return ACL entries of file named FILENAME.
3005 The entries are returned in a format suitable for use in `set-file-acl'
3006 but is otherwise undocumented and subject to change.
3007 Return nil if file does not exist or is not accessible, or if Emacs
3008 was unable to determine the ACL entries. */)
3009 (Lisp_Object filename
)
3011 Lisp_Object absname
;
3012 Lisp_Object handler
;
3013 #ifdef HAVE_ACL_SET_FILE
3015 Lisp_Object acl_string
;
3019 absname
= expand_and_dir_to_file (filename
,
3020 BVAR (current_buffer
, directory
));
3022 /* If the file name has special constructs in it,
3023 call the corresponding file handler. */
3024 handler
= Ffind_file_name_handler (absname
, Qfile_acl
);
3025 if (!NILP (handler
))
3026 return call2 (handler
, Qfile_acl
, absname
);
3028 #ifdef HAVE_ACL_SET_FILE
3029 absname
= ENCODE_FILE (absname
);
3031 acl
= acl_get_file (SSDATA (absname
), ACL_TYPE_ACCESS
);
3035 str
= acl_to_text (acl
, NULL
);
3042 acl_string
= build_string (str
);
3052 DEFUN ("set-file-acl", Fset_file_acl
, Sset_file_acl
,
3054 doc
: /* Set ACL of file named FILENAME to ACL-STRING.
3055 ACL-STRING should contain the textual representation of the ACL
3056 entries in a format suitable for the platform.
3058 Value is t if setting of ACL was successful, nil otherwise.
3060 Setting ACL for local files requires Emacs to be built with ACL
3062 (Lisp_Object filename
, Lisp_Object acl_string
)
3064 Lisp_Object absname
;
3065 Lisp_Object handler
;
3066 #ifdef HAVE_ACL_SET_FILE
3067 Lisp_Object encoded_absname
;
3072 absname
= Fexpand_file_name (filename
, BVAR (current_buffer
, directory
));
3074 /* If the file name has special constructs in it,
3075 call the corresponding file handler. */
3076 handler
= Ffind_file_name_handler (absname
, Qset_file_acl
);
3077 if (!NILP (handler
))
3078 return call3 (handler
, Qset_file_acl
, absname
, acl_string
);
3080 #ifdef HAVE_ACL_SET_FILE
3081 if (STRINGP (acl_string
))
3083 acl
= acl_from_text (SSDATA (acl_string
));
3086 report_file_error ("Converting ACL", absname
);
3090 encoded_absname
= ENCODE_FILE (absname
);
3092 fail
= (acl_set_file (SSDATA (encoded_absname
), ACL_TYPE_ACCESS
,
3095 if (fail
&& acl_errno_valid (errno
))
3096 report_file_error ("Setting ACL", absname
);
3099 return fail
? Qnil
: Qt
;
3106 DEFUN ("file-modes", Ffile_modes
, Sfile_modes
, 1, 1, 0,
3107 doc
: /* Return mode bits of file named FILENAME, as an integer.
3108 Return nil, if file does not exist or is not accessible. */)
3109 (Lisp_Object filename
)
3111 Lisp_Object absname
;
3113 Lisp_Object handler
;
3115 absname
= expand_and_dir_to_file (filename
, BVAR (current_buffer
, directory
));
3117 /* If the file name has special constructs in it,
3118 call the corresponding file handler. */
3119 handler
= Ffind_file_name_handler (absname
, Qfile_modes
);
3120 if (!NILP (handler
))
3121 return call2 (handler
, Qfile_modes
, absname
);
3123 absname
= ENCODE_FILE (absname
);
3125 if (stat (SSDATA (absname
), &st
) < 0)
3128 return make_number (st
.st_mode
& 07777);
3131 DEFUN ("set-file-modes", Fset_file_modes
, Sset_file_modes
, 2, 2,
3132 "(let ((file (read-file-name \"File: \"))) \
3133 (list file (read-file-modes nil file)))",
3134 doc
: /* Set mode bits of file named FILENAME to MODE (an integer).
3135 Only the 12 low bits of MODE are used.
3137 Interactively, mode bits are read by `read-file-modes', which accepts
3138 symbolic notation, like the `chmod' command from GNU Coreutils. */)
3139 (Lisp_Object filename
, Lisp_Object mode
)
3141 Lisp_Object absname
, encoded_absname
;
3142 Lisp_Object handler
;
3144 absname
= Fexpand_file_name (filename
, BVAR (current_buffer
, directory
));
3145 CHECK_NUMBER (mode
);
3147 /* If the file name has special constructs in it,
3148 call the corresponding file handler. */
3149 handler
= Ffind_file_name_handler (absname
, Qset_file_modes
);
3150 if (!NILP (handler
))
3151 return call3 (handler
, Qset_file_modes
, absname
, mode
);
3153 encoded_absname
= ENCODE_FILE (absname
);
3155 if (chmod (SSDATA (encoded_absname
), XINT (mode
) & 07777) < 0)
3156 report_file_error ("Doing chmod", absname
);
3161 DEFUN ("set-default-file-modes", Fset_default_file_modes
, Sset_default_file_modes
, 1, 1, 0,
3162 doc
: /* Set the file permission bits for newly created files.
3163 The argument MODE should be an integer; only the low 9 bits are used.
3164 This setting is inherited by subprocesses. */)
3167 CHECK_NUMBER (mode
);
3169 umask ((~ XINT (mode
)) & 0777);
3174 DEFUN ("default-file-modes", Fdefault_file_modes
, Sdefault_file_modes
, 0, 0, 0,
3175 doc
: /* Return the default file protection for created files.
3176 The value is an integer. */)
3183 realmask
= umask (0);
3187 XSETINT (value
, (~ realmask
) & 0777);
3192 DEFUN ("set-file-times", Fset_file_times
, Sset_file_times
, 1, 2, 0,
3193 doc
: /* Set times of file FILENAME to TIMESTAMP.
3194 Set both access and modification times.
3195 Return t on success, else nil.
3196 Use the current time if TIMESTAMP is nil. TIMESTAMP is in the format of
3198 (Lisp_Object filename
, Lisp_Object timestamp
)
3200 Lisp_Object absname
, encoded_absname
;
3201 Lisp_Object handler
;
3202 struct timespec t
= lisp_time_argument (timestamp
);
3204 absname
= Fexpand_file_name (filename
, BVAR (current_buffer
, directory
));
3206 /* If the file name has special constructs in it,
3207 call the corresponding file handler. */
3208 handler
= Ffind_file_name_handler (absname
, Qset_file_times
);
3209 if (!NILP (handler
))
3210 return call3 (handler
, Qset_file_times
, absname
, timestamp
);
3212 encoded_absname
= ENCODE_FILE (absname
);
3215 if (set_file_times (-1, SSDATA (encoded_absname
), t
, t
))
3218 /* Setting times on a directory always fails. */
3219 if (file_directory_p (SSDATA (encoded_absname
)))
3222 report_file_error ("Setting file times", absname
);
3230 DEFUN ("unix-sync", Funix_sync
, Sunix_sync
, 0, 0, "",
3231 doc
: /* Tell Unix to finish all pending disk updates. */)
3238 #endif /* HAVE_SYNC */
3240 DEFUN ("file-newer-than-file-p", Ffile_newer_than_file_p
, Sfile_newer_than_file_p
, 2, 2, 0,
3241 doc
: /* Return t if file FILE1 is newer than file FILE2.
3242 If FILE1 does not exist, the answer is nil;
3243 otherwise, if FILE2 does not exist, the answer is t. */)
3244 (Lisp_Object file1
, Lisp_Object file2
)
3246 Lisp_Object absname1
, absname2
;
3247 struct stat st1
, st2
;
3248 Lisp_Object handler
;
3249 struct gcpro gcpro1
, gcpro2
;
3251 CHECK_STRING (file1
);
3252 CHECK_STRING (file2
);
3255 GCPRO2 (absname1
, file2
);
3256 absname1
= expand_and_dir_to_file (file1
, BVAR (current_buffer
, directory
));
3257 absname2
= expand_and_dir_to_file (file2
, BVAR (current_buffer
, directory
));
3260 /* If the file name has special constructs in it,
3261 call the corresponding file handler. */
3262 handler
= Ffind_file_name_handler (absname1
, Qfile_newer_than_file_p
);
3264 handler
= Ffind_file_name_handler (absname2
, Qfile_newer_than_file_p
);
3265 if (!NILP (handler
))
3266 return call3 (handler
, Qfile_newer_than_file_p
, absname1
, absname2
);
3268 GCPRO2 (absname1
, absname2
);
3269 absname1
= ENCODE_FILE (absname1
);
3270 absname2
= ENCODE_FILE (absname2
);
3273 if (stat (SSDATA (absname1
), &st1
) < 0)
3276 if (stat (SSDATA (absname2
), &st2
) < 0)
3279 return (timespec_cmp (get_stat_mtime (&st2
), get_stat_mtime (&st1
)) < 0
3283 #ifndef READ_BUF_SIZE
3284 #define READ_BUF_SIZE (64 << 10)
3286 /* Some buffer offsets are stored in 'int' variables. */
3287 verify (READ_BUF_SIZE
<= INT_MAX
);
3289 /* This function is called after Lisp functions to decide a coding
3290 system are called, or when they cause an error. Before they are
3291 called, the current buffer is set unibyte and it contains only a
3292 newly inserted text (thus the buffer was empty before the
3295 The functions may set markers, overlays, text properties, or even
3296 alter the buffer contents, change the current buffer.
3298 Here, we reset all those changes by:
3299 o set back the current buffer.
3300 o move all markers and overlays to BEG.
3301 o remove all text properties.
3302 o set back the buffer multibyteness. */
3305 decide_coding_unwind (Lisp_Object unwind_data
)
3307 Lisp_Object multibyte
, undo_list
, buffer
;
3309 multibyte
= XCAR (unwind_data
);
3310 unwind_data
= XCDR (unwind_data
);
3311 undo_list
= XCAR (unwind_data
);
3312 buffer
= XCDR (unwind_data
);
3314 set_buffer_internal (XBUFFER (buffer
));
3315 adjust_markers_for_delete (BEG
, BEG_BYTE
, Z
, Z_BYTE
);
3316 adjust_overlays_for_delete (BEG
, Z
- BEG
);
3317 set_buffer_intervals (current_buffer
, NULL
);
3318 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
3320 /* Now we are safe to change the buffer's multibyteness directly. */
3321 bset_enable_multibyte_characters (current_buffer
, multibyte
);
3322 bset_undo_list (current_buffer
, undo_list
);
3325 /* Read from a non-regular file. STATE is a Lisp_Save_Value
3326 object where slot 0 is the file descriptor, slot 1 specifies
3327 an offset to put the read bytes, and slot 2 is the maximum
3328 amount of bytes to read. Value is the number of bytes read. */
3331 read_non_regular (Lisp_Object state
)
3337 nbytes
= emacs_read (XSAVE_INTEGER (state
, 0),
3338 ((char *) BEG_ADDR
+ PT_BYTE
- BEG_BYTE
3339 + XSAVE_INTEGER (state
, 1)),
3340 XSAVE_INTEGER (state
, 2));
3342 /* Fast recycle this object for the likely next call. */
3344 return make_number (nbytes
);
3348 /* Condition-case handler used when reading from non-regular files
3349 in insert-file-contents. */
3352 read_non_regular_quit (Lisp_Object ignore
)
3357 /* Return the file offset that VAL represents, checking for type
3358 errors and overflow. */
3360 file_offset (Lisp_Object val
)
3362 if (RANGED_INTEGERP (0, val
, TYPE_MAXIMUM (off_t
)))
3367 double v
= XFLOAT_DATA (val
);
3369 && (sizeof (off_t
) < sizeof v
3370 ? v
<= TYPE_MAXIMUM (off_t
)
3371 : v
< TYPE_MAXIMUM (off_t
)))
3375 wrong_type_argument (intern ("file-offset"), val
);
3378 /* Return a special time value indicating the error number ERRNUM. */
3379 static struct timespec
3380 time_error_value (int errnum
)
3382 int ns
= (errnum
== ENOENT
|| errnum
== EACCES
|| errnum
== ENOTDIR
3383 ? NONEXISTENT_MODTIME_NSECS
3384 : UNKNOWN_MODTIME_NSECS
);
3385 return make_timespec (0, ns
);
3388 DEFUN ("insert-file-contents", Finsert_file_contents
, Sinsert_file_contents
,
3390 doc
: /* Insert contents of file FILENAME after point.
3391 Returns list of absolute file name and number of characters inserted.
3392 If second argument VISIT is non-nil, the buffer's visited filename and
3393 last save file modtime are set, and it is marked unmodified. If
3394 visiting and the file does not exist, visiting is completed before the
3397 The optional third and fourth arguments BEG and END specify what portion
3398 of the file to insert. These arguments count bytes in the file, not
3399 characters in the buffer. If VISIT is non-nil, BEG and END must be nil.
3401 If optional fifth argument REPLACE is non-nil, replace the current
3402 buffer contents (in the accessible portion) with the file contents.
3403 This is better than simply deleting and inserting the whole thing
3404 because (1) it preserves some marker positions and (2) it puts less data
3405 in the undo list. When REPLACE is non-nil, the second return value is
3406 the number of characters that replace previous buffer contents.
3408 This function does code conversion according to the value of
3409 `coding-system-for-read' or `file-coding-system-alist', and sets the
3410 variable `last-coding-system-used' to the coding system actually used.
3412 In addition, this function decodes the inserted text from known formats
3413 by calling `format-decode', which see. */)
3414 (Lisp_Object filename
, Lisp_Object visit
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object replace
)
3417 struct timespec mtime
;
3419 ptrdiff_t inserted
= 0;
3421 off_t beg_offset
, end_offset
;
3423 ptrdiff_t count
= SPECPDL_INDEX ();
3424 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
3425 Lisp_Object handler
, val
, insval
, orig_filename
, old_undo
;
3427 ptrdiff_t total
= 0;
3428 bool not_regular
= 0;
3430 char read_buf
[READ_BUF_SIZE
];
3431 struct coding_system coding
;
3432 bool replace_handled
= 0;
3433 bool set_coding_system
= 0;
3434 Lisp_Object coding_system
;
3436 /* If the undo log only contains the insertion, there's no point
3437 keeping it. It's typically when we first fill a file-buffer. */
3438 bool empty_undo_list_p
3439 = (!NILP (visit
) && NILP (BVAR (current_buffer
, undo_list
))
3441 Lisp_Object old_Vdeactivate_mark
= Vdeactivate_mark
;
3442 bool we_locked_file
= 0;
3445 if (current_buffer
->base_buffer
&& ! NILP (visit
))
3446 error ("Cannot do file visiting in an indirect buffer");
3448 if (!NILP (BVAR (current_buffer
, read_only
)))
3449 Fbarf_if_buffer_read_only ();
3453 orig_filename
= Qnil
;
3456 GCPRO5 (filename
, val
, p
, orig_filename
, old_undo
);
3458 CHECK_STRING (filename
);
3459 filename
= Fexpand_file_name (filename
, Qnil
);
3461 /* The value Qnil means that the coding system is not yet
3463 coding_system
= Qnil
;
3465 /* If the file name has special constructs in it,
3466 call the corresponding file handler. */
3467 handler
= Ffind_file_name_handler (filename
, Qinsert_file_contents
);
3468 if (!NILP (handler
))
3470 val
= call6 (handler
, Qinsert_file_contents
, filename
,
3471 visit
, beg
, end
, replace
);
3472 if (CONSP (val
) && CONSP (XCDR (val
))
3473 && RANGED_INTEGERP (0, XCAR (XCDR (val
)), ZV
- PT
))
3474 inserted
= XINT (XCAR (XCDR (val
)));
3478 orig_filename
= filename
;
3479 filename
= ENCODE_FILE (filename
);
3481 fd
= emacs_open (SSDATA (filename
), O_RDONLY
, 0);
3486 report_file_error ("Opening input file", orig_filename
);
3487 mtime
= time_error_value (save_errno
);
3489 if (!NILP (Vcoding_system_for_read
))
3490 Fset (Qbuffer_file_coding_system
, Vcoding_system_for_read
);
3494 fd_index
= SPECPDL_INDEX ();
3495 record_unwind_protect_int (close_file_unwind
, fd
);
3497 /* Replacement should preserve point as it preserves markers. */
3498 if (!NILP (replace
))
3499 record_unwind_protect (restore_point_unwind
, Fpoint_marker ());
3501 if (fstat (fd
, &st
) != 0)
3502 report_file_error ("Input file status", orig_filename
);
3503 mtime
= get_stat_mtime (&st
);
3505 /* This code will need to be changed in order to work on named
3506 pipes, and it's probably just not worth it. So we should at
3507 least signal an error. */
3508 if (!S_ISREG (st
.st_mode
))
3515 if (! NILP (replace
) || ! NILP (beg
) || ! NILP (end
))
3516 xsignal2 (Qfile_error
,
3517 build_string ("not a regular file"), orig_filename
);
3522 if (!NILP (beg
) || !NILP (end
))
3523 error ("Attempt to visit less than an entire file");
3524 if (BEG
< Z
&& NILP (replace
))
3525 error ("Cannot do file visiting in a non-empty buffer");
3529 beg_offset
= file_offset (beg
);
3534 end_offset
= file_offset (end
);
3538 end_offset
= TYPE_MAXIMUM (off_t
);
3541 end_offset
= st
.st_size
;
3543 /* A negative size can happen on a platform that allows file
3544 sizes greater than the maximum off_t value. */
3548 /* The file size returned from stat may be zero, but data
3549 may be readable nonetheless, for example when this is a
3550 file in the /proc filesystem. */
3551 if (end_offset
== 0)
3552 end_offset
= READ_BUF_SIZE
;
3556 /* Check now whether the buffer will become too large,
3557 in the likely case where the file's length is not changing.
3558 This saves a lot of needless work before a buffer overflow. */
3561 /* The likely offset where we will stop reading. We could read
3562 more (or less), if the file grows (or shrinks) as we read it. */
3563 off_t likely_end
= min (end_offset
, st
.st_size
);
3565 if (beg_offset
< likely_end
)
3568 = Z_BYTE
- (!NILP (replace
) ? ZV_BYTE
- BEGV_BYTE
: 0);
3569 ptrdiff_t buf_growth_max
= BUF_BYTES_MAX
- buf_bytes
;
3570 off_t likely_growth
= likely_end
- beg_offset
;
3571 if (buf_growth_max
< likely_growth
)
3576 /* Prevent redisplay optimizations. */
3577 current_buffer
->clip_changed
= 1;
3579 if (EQ (Vcoding_system_for_read
, Qauto_save_coding
))
3581 coding_system
= coding_inherit_eol_type (Qutf_8_emacs
, Qunix
);
3582 setup_coding_system (coding_system
, &coding
);
3583 /* Ensure we set Vlast_coding_system_used. */
3584 set_coding_system
= 1;
3588 /* Decide the coding system to use for reading the file now
3589 because we can't use an optimized method for handling
3590 `coding:' tag if the current buffer is not empty. */
3591 if (!NILP (Vcoding_system_for_read
))
3592 coding_system
= Vcoding_system_for_read
;
3595 /* Don't try looking inside a file for a coding system
3596 specification if it is not seekable. */
3597 if (! not_regular
&& ! NILP (Vset_auto_coding_function
))
3599 /* Find a coding system specified in the heading two
3600 lines or in the tailing several lines of the file.
3601 We assume that the 1K-byte and 3K-byte for heading
3602 and tailing respectively are sufficient for this
3606 if (st
.st_size
<= (1024 * 4))
3607 nread
= emacs_read (fd
, read_buf
, 1024 * 4);
3610 nread
= emacs_read (fd
, read_buf
, 1024);
3614 if (lseek (fd
, - (1024 * 3), SEEK_END
) < 0)
3615 report_file_error ("Setting file position",
3617 ntail
= emacs_read (fd
, read_buf
+ nread
, 1024 * 3);
3618 nread
= ntail
< 0 ? ntail
: nread
+ ntail
;
3623 report_file_error ("Read error", orig_filename
);
3626 struct buffer
*prev
= current_buffer
;
3627 Lisp_Object workbuf
;
3630 record_unwind_current_buffer ();
3632 workbuf
= Fget_buffer_create (build_string (" *code-converting-work*"));
3633 buf
= XBUFFER (workbuf
);
3635 delete_all_overlays (buf
);
3636 bset_directory (buf
, BVAR (current_buffer
, directory
));
3637 bset_read_only (buf
, Qnil
);
3638 bset_filename (buf
, Qnil
);
3639 bset_undo_list (buf
, Qt
);
3640 eassert (buf
->overlays_before
== NULL
);
3641 eassert (buf
->overlays_after
== NULL
);
3643 set_buffer_internal (buf
);
3645 bset_enable_multibyte_characters (buf
, Qnil
);
3647 insert_1_both ((char *) read_buf
, nread
, nread
, 0, 0, 0);
3648 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
3649 coding_system
= call2 (Vset_auto_coding_function
,
3650 filename
, make_number (nread
));
3651 set_buffer_internal (prev
);
3653 /* Discard the unwind protect for recovering the
3657 /* Rewind the file for the actual read done later. */
3658 if (lseek (fd
, 0, SEEK_SET
) < 0)
3659 report_file_error ("Setting file position", orig_filename
);
3663 if (NILP (coding_system
))
3665 /* If we have not yet decided a coding system, check
3666 file-coding-system-alist. */
3667 Lisp_Object args
[6];
3669 args
[0] = Qinsert_file_contents
, args
[1] = orig_filename
;
3670 args
[2] = visit
, args
[3] = beg
, args
[4] = end
, args
[5] = replace
;
3671 coding_system
= Ffind_operation_coding_system (6, args
);
3672 if (CONSP (coding_system
))
3673 coding_system
= XCAR (coding_system
);
3677 if (NILP (coding_system
))
3678 coding_system
= Qundecided
;
3680 CHECK_CODING_SYSTEM (coding_system
);
3682 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3683 /* We must suppress all character code conversion except for
3684 end-of-line conversion. */
3685 coding_system
= raw_text_coding_system (coding_system
);
3687 setup_coding_system (coding_system
, &coding
);
3688 /* Ensure we set Vlast_coding_system_used. */
3689 set_coding_system
= 1;
3692 /* If requested, replace the accessible part of the buffer
3693 with the file contents. Avoid replacing text at the
3694 beginning or end of the buffer that matches the file contents;
3695 that preserves markers pointing to the unchanged parts.
3697 Here we implement this feature in an optimized way
3698 for the case where code conversion is NOT needed.
3699 The following if-statement handles the case of conversion
3700 in a less optimal way.
3702 If the code conversion is "automatic" then we try using this
3703 method and hope for the best.
3704 But if we discover the need for conversion, we give up on this method
3705 and let the following if-statement handle the replace job. */
3708 && (NILP (coding_system
)
3709 || ! CODING_REQUIRE_DECODING (&coding
)))
3711 /* same_at_start and same_at_end count bytes,
3712 because file access counts bytes
3713 and BEG and END count bytes. */
3714 ptrdiff_t same_at_start
= BEGV_BYTE
;
3715 ptrdiff_t same_at_end
= ZV_BYTE
;
3717 /* There is still a possibility we will find the need to do code
3718 conversion. If that happens, set this variable to
3719 give up on handling REPLACE in the optimized way. */
3720 bool giveup_match_end
= 0;
3722 if (beg_offset
!= 0)
3724 if (lseek (fd
, beg_offset
, SEEK_SET
) < 0)
3725 report_file_error ("Setting file position", orig_filename
);
3730 /* Count how many chars at the start of the file
3731 match the text at the beginning of the buffer. */
3736 nread
= emacs_read (fd
, read_buf
, sizeof read_buf
);
3738 report_file_error ("Read error", orig_filename
);
3739 else if (nread
== 0)
3742 if (CODING_REQUIRE_DETECTION (&coding
))
3744 coding_system
= detect_coding_system ((unsigned char *) read_buf
,
3747 setup_coding_system (coding_system
, &coding
);
3750 if (CODING_REQUIRE_DECODING (&coding
))
3751 /* We found that the file should be decoded somehow.
3752 Let's give up here. */
3754 giveup_match_end
= 1;
3759 while (bufpos
< nread
&& same_at_start
< ZV_BYTE
3760 && FETCH_BYTE (same_at_start
) == read_buf
[bufpos
])
3761 same_at_start
++, bufpos
++;
3762 /* If we found a discrepancy, stop the scan.
3763 Otherwise loop around and scan the next bufferful. */
3764 if (bufpos
!= nread
)
3768 /* If the file matches the buffer completely,
3769 there's no need to replace anything. */
3770 if (same_at_start
- BEGV_BYTE
== end_offset
- beg_offset
)
3773 clear_unwind_protect (fd_index
);
3775 /* Truncate the buffer to the size of the file. */
3776 del_range_1 (same_at_start
, same_at_end
, 0, 0);
3781 /* Count how many chars at the end of the file
3782 match the text at the end of the buffer. But, if we have
3783 already found that decoding is necessary, don't waste time. */
3784 while (!giveup_match_end
)
3786 int total_read
, nread
, bufpos
, trial
;
3789 /* At what file position are we now scanning? */
3790 curpos
= end_offset
- (ZV_BYTE
- same_at_end
);
3791 /* If the entire file matches the buffer tail, stop the scan. */
3794 /* How much can we scan in the next step? */
3795 trial
= min (curpos
, sizeof read_buf
);
3796 if (lseek (fd
, curpos
- trial
, SEEK_SET
) < 0)
3797 report_file_error ("Setting file position", orig_filename
);
3799 total_read
= nread
= 0;
3800 while (total_read
< trial
)
3802 nread
= emacs_read (fd
, read_buf
+ total_read
, trial
- total_read
);
3804 report_file_error ("Read error", orig_filename
);
3805 else if (nread
== 0)
3807 total_read
+= nread
;
3810 /* Scan this bufferful from the end, comparing with
3811 the Emacs buffer. */
3812 bufpos
= total_read
;
3814 /* Compare with same_at_start to avoid counting some buffer text
3815 as matching both at the file's beginning and at the end. */
3816 while (bufpos
> 0 && same_at_end
> same_at_start
3817 && FETCH_BYTE (same_at_end
- 1) == read_buf
[bufpos
- 1])
3818 same_at_end
--, bufpos
--;
3820 /* If we found a discrepancy, stop the scan.
3821 Otherwise loop around and scan the preceding bufferful. */
3824 /* If this discrepancy is because of code conversion,
3825 we cannot use this method; giveup and try the other. */
3826 if (same_at_end
> same_at_start
3827 && FETCH_BYTE (same_at_end
- 1) >= 0200
3828 && ! NILP (BVAR (current_buffer
, enable_multibyte_characters
))
3829 && (CODING_MAY_REQUIRE_DECODING (&coding
)))
3830 giveup_match_end
= 1;
3839 if (! giveup_match_end
)
3843 /* We win! We can handle REPLACE the optimized way. */
3845 /* Extend the start of non-matching text area to multibyte
3846 character boundary. */
3847 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3848 while (same_at_start
> BEGV_BYTE
3849 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_start
)))
3852 /* Extend the end of non-matching text area to multibyte
3853 character boundary. */
3854 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3855 while (same_at_end
< ZV_BYTE
3856 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_end
)))
3859 /* Don't try to reuse the same piece of text twice. */
3860 overlap
= (same_at_start
- BEGV_BYTE
3862 + (! NILP (end
) ? end_offset
: st
.st_size
) - ZV_BYTE
));
3864 same_at_end
+= overlap
;
3866 /* Arrange to read only the nonmatching middle part of the file. */
3867 beg_offset
+= same_at_start
- BEGV_BYTE
;
3868 end_offset
-= ZV_BYTE
- same_at_end
;
3870 del_range_byte (same_at_start
, same_at_end
, 0);
3871 /* Insert from the file at the proper position. */
3872 temp
= BYTE_TO_CHAR (same_at_start
);
3873 SET_PT_BOTH (temp
, same_at_start
);
3875 /* If display currently starts at beginning of line,
3876 keep it that way. */
3877 if (XBUFFER (XWINDOW (selected_window
)->contents
) == current_buffer
)
3878 XWINDOW (selected_window
)->start_at_line_beg
= !NILP (Fbolp ());
3880 replace_handled
= 1;
3884 /* If requested, replace the accessible part of the buffer
3885 with the file contents. Avoid replacing text at the
3886 beginning or end of the buffer that matches the file contents;
3887 that preserves markers pointing to the unchanged parts.
3889 Here we implement this feature for the case where code conversion
3890 is needed, in a simple way that needs a lot of memory.
3891 The preceding if-statement handles the case of no conversion
3892 in a more optimized way. */
3893 if (!NILP (replace
) && ! replace_handled
&& BEGV
< ZV
)
3895 ptrdiff_t same_at_start
= BEGV_BYTE
;
3896 ptrdiff_t same_at_end
= ZV_BYTE
;
3897 ptrdiff_t same_at_start_charpos
;
3898 ptrdiff_t inserted_chars
;
3901 unsigned char *decoded
;
3904 ptrdiff_t this_count
= SPECPDL_INDEX ();
3906 = ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3907 Lisp_Object conversion_buffer
;
3908 struct gcpro gcpro1
;
3910 conversion_buffer
= code_conversion_save (1, multibyte
);
3912 /* First read the whole file, performing code conversion into
3913 CONVERSION_BUFFER. */
3915 if (lseek (fd
, beg_offset
, SEEK_SET
) < 0)
3916 report_file_error ("Setting file position", orig_filename
);
3918 inserted
= 0; /* Bytes put into CONVERSION_BUFFER so far. */
3919 unprocessed
= 0; /* Bytes not processed in previous loop. */
3921 GCPRO1 (conversion_buffer
);
3924 /* Read at most READ_BUF_SIZE bytes at a time, to allow
3925 quitting while reading a huge file. */
3927 /* Allow quitting out of the actual I/O. */
3930 this = emacs_read (fd
, read_buf
+ unprocessed
,
3931 READ_BUF_SIZE
- unprocessed
);
3937 BUF_TEMP_SET_PT (XBUFFER (conversion_buffer
),
3938 BUF_Z (XBUFFER (conversion_buffer
)));
3939 decode_coding_c_string (&coding
, (unsigned char *) read_buf
,
3940 unprocessed
+ this, conversion_buffer
);
3941 unprocessed
= coding
.carryover_bytes
;
3942 if (coding
.carryover_bytes
> 0)
3943 memcpy (read_buf
, coding
.carryover
, unprocessed
);
3947 report_file_error ("Read error", orig_filename
);
3949 clear_unwind_protect (fd_index
);
3951 if (unprocessed
> 0)
3953 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
3954 decode_coding_c_string (&coding
, (unsigned char *) read_buf
,
3955 unprocessed
, conversion_buffer
);
3956 coding
.mode
&= ~CODING_MODE_LAST_BLOCK
;
3959 coding_system
= CODING_ID_NAME (coding
.id
);
3960 set_coding_system
= 1;
3961 decoded
= BUF_BEG_ADDR (XBUFFER (conversion_buffer
));
3962 inserted
= (BUF_Z_BYTE (XBUFFER (conversion_buffer
))
3963 - BUF_BEG_BYTE (XBUFFER (conversion_buffer
)));
3965 /* Compare the beginning of the converted string with the buffer
3969 while (bufpos
< inserted
&& same_at_start
< same_at_end
3970 && FETCH_BYTE (same_at_start
) == decoded
[bufpos
])
3971 same_at_start
++, bufpos
++;
3973 /* If the file matches the head of buffer completely,
3974 there's no need to replace anything. */
3976 if (bufpos
== inserted
)
3978 /* Truncate the buffer to the size of the file. */
3979 if (same_at_start
!= same_at_end
)
3980 del_range_byte (same_at_start
, same_at_end
, 0);
3983 unbind_to (this_count
, Qnil
);
3987 /* Extend the start of non-matching text area to the previous
3988 multibyte character boundary. */
3989 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3990 while (same_at_start
> BEGV_BYTE
3991 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_start
)))
3994 /* Scan this bufferful from the end, comparing with
3995 the Emacs buffer. */
3998 /* Compare with same_at_start to avoid counting some buffer text
3999 as matching both at the file's beginning and at the end. */
4000 while (bufpos
> 0 && same_at_end
> same_at_start
4001 && FETCH_BYTE (same_at_end
- 1) == decoded
[bufpos
- 1])
4002 same_at_end
--, bufpos
--;
4004 /* Extend the end of non-matching text area to the next
4005 multibyte character boundary. */
4006 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
4007 while (same_at_end
< ZV_BYTE
4008 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_end
)))
4011 /* Don't try to reuse the same piece of text twice. */
4012 overlap
= same_at_start
- BEGV_BYTE
- (same_at_end
+ inserted
- ZV_BYTE
);
4014 same_at_end
+= overlap
;
4016 /* If display currently starts at beginning of line,
4017 keep it that way. */
4018 if (XBUFFER (XWINDOW (selected_window
)->contents
) == current_buffer
)
4019 XWINDOW (selected_window
)->start_at_line_beg
= !NILP (Fbolp ());
4021 /* Replace the chars that we need to replace,
4022 and update INSERTED to equal the number of bytes
4023 we are taking from the decoded string. */
4024 inserted
-= (ZV_BYTE
- same_at_end
) + (same_at_start
- BEGV_BYTE
);
4026 if (same_at_end
!= same_at_start
)
4028 del_range_byte (same_at_start
, same_at_end
, 0);
4030 eassert (same_at_start
== GPT_BYTE
);
4031 same_at_start
= GPT_BYTE
;
4035 temp
= BYTE_TO_CHAR (same_at_start
);
4037 /* Insert from the file at the proper position. */
4038 SET_PT_BOTH (temp
, same_at_start
);
4039 same_at_start_charpos
4040 = buf_bytepos_to_charpos (XBUFFER (conversion_buffer
),
4041 same_at_start
- BEGV_BYTE
4042 + BUF_BEG_BYTE (XBUFFER (conversion_buffer
)));
4043 eassert (same_at_start_charpos
== temp
- (BEGV
- BEG
));
4045 = (buf_bytepos_to_charpos (XBUFFER (conversion_buffer
),
4046 same_at_start
+ inserted
- BEGV_BYTE
4047 + BUF_BEG_BYTE (XBUFFER (conversion_buffer
)))
4048 - same_at_start_charpos
);
4049 /* This binding is to avoid ask-user-about-supersession-threat
4050 being called in insert_from_buffer (via in
4051 prepare_to_modify_buffer). */
4052 specbind (intern ("buffer-file-name"), Qnil
);
4053 insert_from_buffer (XBUFFER (conversion_buffer
),
4054 same_at_start_charpos
, inserted_chars
, 0);
4055 /* Set `inserted' to the number of inserted characters. */
4056 inserted
= PT
- temp
;
4057 /* Set point before the inserted characters. */
4058 SET_PT_BOTH (temp
, same_at_start
);
4060 unbind_to (this_count
, Qnil
);
4066 total
= end_offset
- beg_offset
;
4068 /* For a special file, all we can do is guess. */
4069 total
= READ_BUF_SIZE
;
4071 if (NILP (visit
) && total
> 0)
4073 #ifdef CLASH_DETECTION
4074 if (!NILP (BVAR (current_buffer
, file_truename
))
4075 /* Make binding buffer-file-name to nil effective. */
4076 && !NILP (BVAR (current_buffer
, filename
))
4077 && SAVE_MODIFF
>= MODIFF
)
4079 #endif /* CLASH_DETECTION */
4080 prepare_to_modify_buffer (GPT
, GPT
, NULL
);
4083 move_gap_both (PT
, PT_BYTE
);
4084 if (GAP_SIZE
< total
)
4085 make_gap (total
- GAP_SIZE
);
4087 if (beg_offset
!= 0 || !NILP (replace
))
4089 if (lseek (fd
, beg_offset
, SEEK_SET
) < 0)
4090 report_file_error ("Setting file position", orig_filename
);
4093 /* In the following loop, HOW_MUCH contains the total bytes read so
4094 far for a regular file, and not changed for a special file. But,
4095 before exiting the loop, it is set to a negative value if I/O
4099 /* Total bytes inserted. */
4102 /* Here, we don't do code conversion in the loop. It is done by
4103 decode_coding_gap after all data are read into the buffer. */
4105 ptrdiff_t gap_size
= GAP_SIZE
;
4107 while (how_much
< total
)
4109 /* try is reserved in some compilers (Microsoft C) */
4110 ptrdiff_t trytry
= min (total
- how_much
, READ_BUF_SIZE
);
4117 /* Maybe make more room. */
4118 if (gap_size
< trytry
)
4120 make_gap (trytry
- gap_size
);
4121 gap_size
= GAP_SIZE
- inserted
;
4124 /* Read from the file, capturing `quit'. When an
4125 error occurs, end the loop, and arrange for a quit
4126 to be signaled after decoding the text we read. */
4127 nbytes
= internal_condition_case_1
4129 make_save_int_int_int (fd
, inserted
, trytry
),
4130 Qerror
, read_non_regular_quit
);
4138 this = XINT (nbytes
);
4142 /* Allow quitting out of the actual I/O. We don't make text
4143 part of the buffer until all the reading is done, so a C-g
4144 here doesn't do any harm. */
4147 this = emacs_read (fd
,
4148 ((char *) BEG_ADDR
+ PT_BYTE
- BEG_BYTE
4162 /* For a regular file, where TOTAL is the real size,
4163 count HOW_MUCH to compare with it.
4164 For a special file, where TOTAL is just a buffer size,
4165 so don't bother counting in HOW_MUCH.
4166 (INSERTED is where we count the number of characters inserted.) */
4173 /* Now we have either read all the file data into the gap,
4174 or stop reading on I/O error or quit. If nothing was
4175 read, undo marking the buffer modified. */
4179 #ifdef CLASH_DETECTION
4181 unlock_file (BVAR (current_buffer
, file_truename
));
4183 Vdeactivate_mark
= old_Vdeactivate_mark
;
4186 Vdeactivate_mark
= Qt
;
4189 clear_unwind_protect (fd_index
);
4192 report_file_error ("Read error", orig_filename
);
4194 /* Make the text read part of the buffer. */
4195 GAP_SIZE
-= inserted
;
4197 GPT_BYTE
+= inserted
;
4199 ZV_BYTE
+= inserted
;
4204 /* Put an anchor to ensure multi-byte form ends at gap. */
4209 if (NILP (coding_system
))
4211 /* The coding system is not yet decided. Decide it by an
4212 optimized method for handling `coding:' tag.
4214 Note that we can get here only if the buffer was empty
4215 before the insertion. */
4217 if (!NILP (Vcoding_system_for_read
))
4218 coding_system
= Vcoding_system_for_read
;
4221 /* Since we are sure that the current buffer was empty
4222 before the insertion, we can toggle
4223 enable-multibyte-characters directly here without taking
4224 care of marker adjustment. By this way, we can run Lisp
4225 program safely before decoding the inserted text. */
4226 Lisp_Object unwind_data
;
4227 ptrdiff_t count1
= SPECPDL_INDEX ();
4229 unwind_data
= Fcons (BVAR (current_buffer
, enable_multibyte_characters
),
4230 Fcons (BVAR (current_buffer
, undo_list
),
4231 Fcurrent_buffer ()));
4232 bset_enable_multibyte_characters (current_buffer
, Qnil
);
4233 bset_undo_list (current_buffer
, Qt
);
4234 record_unwind_protect (decide_coding_unwind
, unwind_data
);
4236 if (inserted
> 0 && ! NILP (Vset_auto_coding_function
))
4238 coding_system
= call2 (Vset_auto_coding_function
,
4239 filename
, make_number (inserted
));
4242 if (NILP (coding_system
))
4244 /* If the coding system is not yet decided, check
4245 file-coding-system-alist. */
4246 Lisp_Object args
[6];
4248 args
[0] = Qinsert_file_contents
, args
[1] = orig_filename
;
4249 args
[2] = visit
, args
[3] = beg
, args
[4] = end
, args
[5] = Qnil
;
4250 coding_system
= Ffind_operation_coding_system (6, args
);
4251 if (CONSP (coding_system
))
4252 coding_system
= XCAR (coding_system
);
4254 unbind_to (count1
, Qnil
);
4255 inserted
= Z_BYTE
- BEG_BYTE
;
4258 if (NILP (coding_system
))
4259 coding_system
= Qundecided
;
4261 CHECK_CODING_SYSTEM (coding_system
);
4263 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
4264 /* We must suppress all character code conversion except for
4265 end-of-line conversion. */
4266 coding_system
= raw_text_coding_system (coding_system
);
4267 setup_coding_system (coding_system
, &coding
);
4268 /* Ensure we set Vlast_coding_system_used. */
4269 set_coding_system
= 1;
4274 /* When we visit a file by raw-text, we change the buffer to
4276 if (CODING_FOR_UNIBYTE (&coding
)
4277 /* Can't do this if part of the buffer might be preserved. */
4279 /* Visiting a file with these coding system makes the buffer
4281 bset_enable_multibyte_characters (current_buffer
, Qnil
);
4284 coding
.dst_multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
4285 if (CODING_MAY_REQUIRE_DECODING (&coding
)
4286 && (inserted
> 0 || CODING_REQUIRE_FLUSHING (&coding
)))
4288 move_gap_both (PT
, PT_BYTE
);
4289 GAP_SIZE
+= inserted
;
4290 ZV_BYTE
-= inserted
;
4294 decode_coding_gap (&coding
, inserted
, inserted
);
4295 inserted
= coding
.produced_char
;
4296 coding_system
= CODING_ID_NAME (coding
.id
);
4298 else if (inserted
> 0)
4299 adjust_after_insert (PT
, PT_BYTE
, PT
+ inserted
, PT_BYTE
+ inserted
,
4302 /* Call after-change hooks for the inserted text, aside from the case
4303 of normal visiting (not with REPLACE), which is done in a new buffer
4304 "before" the buffer is changed. */
4305 if (inserted
> 0 && total
> 0
4306 && (NILP (visit
) || !NILP (replace
)))
4308 signal_after_change (PT
, 0, inserted
);
4309 update_compositions (PT
, PT
, CHECK_BORDER
);
4312 /* Now INSERTED is measured in characters. */
4318 if (empty_undo_list_p
)
4319 bset_undo_list (current_buffer
, Qnil
);
4323 current_buffer
->modtime
= mtime
;
4324 current_buffer
->modtime_size
= st
.st_size
;
4325 bset_filename (current_buffer
, orig_filename
);
4328 SAVE_MODIFF
= MODIFF
;
4329 BUF_AUTOSAVE_MODIFF (current_buffer
) = MODIFF
;
4330 XSETFASTINT (BVAR (current_buffer
, save_length
), Z
- BEG
);
4331 #ifdef CLASH_DETECTION
4334 if (!NILP (BVAR (current_buffer
, file_truename
)))
4335 unlock_file (BVAR (current_buffer
, file_truename
));
4336 unlock_file (filename
);
4338 #endif /* CLASH_DETECTION */
4340 xsignal2 (Qfile_error
,
4341 build_string ("not a regular file"), orig_filename
);
4344 if (set_coding_system
)
4345 Vlast_coding_system_used
= coding_system
;
4347 if (! NILP (Ffboundp (Qafter_insert_file_set_coding
)))
4349 insval
= call2 (Qafter_insert_file_set_coding
, make_number (inserted
),
4351 if (! NILP (insval
))
4353 if (! RANGED_INTEGERP (0, insval
, ZV
- PT
))
4354 wrong_type_argument (intern ("inserted-chars"), insval
);
4355 inserted
= XFASTINT (insval
);
4359 /* Decode file format. */
4362 /* Don't run point motion or modification hooks when decoding. */
4363 ptrdiff_t count1
= SPECPDL_INDEX ();
4364 ptrdiff_t old_inserted
= inserted
;
4365 specbind (Qinhibit_point_motion_hooks
, Qt
);
4366 specbind (Qinhibit_modification_hooks
, Qt
);
4368 /* Save old undo list and don't record undo for decoding. */
4369 old_undo
= BVAR (current_buffer
, undo_list
);
4370 bset_undo_list (current_buffer
, Qt
);
4374 insval
= call3 (Qformat_decode
,
4375 Qnil
, make_number (inserted
), visit
);
4376 if (! RANGED_INTEGERP (0, insval
, ZV
- PT
))
4377 wrong_type_argument (intern ("inserted-chars"), insval
);
4378 inserted
= XFASTINT (insval
);
4382 /* If REPLACE is non-nil and we succeeded in not replacing the
4383 beginning or end of the buffer text with the file's contents,
4384 call format-decode with `point' positioned at the beginning
4385 of the buffer and `inserted' equaling the number of
4386 characters in the buffer. Otherwise, format-decode might
4387 fail to correctly analyze the beginning or end of the buffer.
4388 Hence we temporarily save `point' and `inserted' here and
4389 restore `point' iff format-decode did not insert or delete
4390 any text. Otherwise we leave `point' at point-min. */
4391 ptrdiff_t opoint
= PT
;
4392 ptrdiff_t opoint_byte
= PT_BYTE
;
4393 ptrdiff_t oinserted
= ZV
- BEGV
;
4394 EMACS_INT ochars_modiff
= CHARS_MODIFF
;
4396 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
4397 insval
= call3 (Qformat_decode
,
4398 Qnil
, make_number (oinserted
), visit
);
4399 if (! RANGED_INTEGERP (0, insval
, ZV
- PT
))
4400 wrong_type_argument (intern ("inserted-chars"), insval
);
4401 if (ochars_modiff
== CHARS_MODIFF
)
4402 /* format_decode didn't modify buffer's characters => move
4403 point back to position before inserted text and leave
4404 value of inserted alone. */
4405 SET_PT_BOTH (opoint
, opoint_byte
);
4407 /* format_decode modified buffer's characters => consider
4408 entire buffer changed and leave point at point-min. */
4409 inserted
= XFASTINT (insval
);
4412 /* For consistency with format-decode call these now iff inserted > 0
4413 (martin 2007-06-28). */
4414 p
= Vafter_insert_file_functions
;
4419 insval
= call1 (XCAR (p
), make_number (inserted
));
4422 if (! RANGED_INTEGERP (0, insval
, ZV
- PT
))
4423 wrong_type_argument (intern ("inserted-chars"), insval
);
4424 inserted
= XFASTINT (insval
);
4429 /* For the rationale of this see the comment on
4430 format-decode above. */
4431 ptrdiff_t opoint
= PT
;
4432 ptrdiff_t opoint_byte
= PT_BYTE
;
4433 ptrdiff_t oinserted
= ZV
- BEGV
;
4434 EMACS_INT ochars_modiff
= CHARS_MODIFF
;
4436 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
4437 insval
= call1 (XCAR (p
), make_number (oinserted
));
4440 if (! RANGED_INTEGERP (0, insval
, ZV
- PT
))
4441 wrong_type_argument (intern ("inserted-chars"), insval
);
4442 if (ochars_modiff
== CHARS_MODIFF
)
4443 /* after_insert_file_functions didn't modify
4444 buffer's characters => move point back to
4445 position before inserted text and leave value of
4447 SET_PT_BOTH (opoint
, opoint_byte
);
4449 /* after_insert_file_functions did modify buffer's
4450 characters => consider entire buffer changed and
4451 leave point at point-min. */
4452 inserted
= XFASTINT (insval
);
4460 if (!empty_undo_list_p
)
4462 bset_undo_list (current_buffer
, old_undo
);
4463 if (CONSP (old_undo
) && inserted
!= old_inserted
)
4465 /* Adjust the last undo record for the size change during
4466 the format conversion. */
4467 Lisp_Object tem
= XCAR (old_undo
);
4468 if (CONSP (tem
) && INTEGERP (XCAR (tem
))
4469 && INTEGERP (XCDR (tem
))
4470 && XFASTINT (XCDR (tem
)) == PT
+ old_inserted
)
4471 XSETCDR (tem
, make_number (PT
+ inserted
));
4475 /* If undo_list was Qt before, keep it that way.
4476 Otherwise start with an empty undo_list. */
4477 bset_undo_list (current_buffer
, EQ (old_undo
, Qt
) ? Qt
: Qnil
);
4479 unbind_to (count1
, Qnil
);
4483 && current_buffer
->modtime
.tv_nsec
== NONEXISTENT_MODTIME_NSECS
)
4485 /* If visiting nonexistent file, return nil. */
4486 report_file_errno ("Opening input file", orig_filename
, save_errno
);
4489 /* We made a lot of deletions and insertions above, so invalidate
4490 the newline cache for the entire region of the inserted
4492 if (current_buffer
->newline_cache
)
4493 invalidate_region_cache (current_buffer
,
4494 current_buffer
->newline_cache
,
4495 PT
- BEG
, Z
- PT
- inserted
);
4498 Fsignal (Qquit
, Qnil
);
4500 /* Retval needs to be dealt with in all cases consistently. */
4502 val
= list2 (orig_filename
, make_number (inserted
));
4504 RETURN_UNGCPRO (unbind_to (count
, val
));
4507 static Lisp_Object
build_annotations (Lisp_Object
, Lisp_Object
);
4510 build_annotations_unwind (Lisp_Object arg
)
4512 Vwrite_region_annotation_buffers
= arg
;
4515 /* Decide the coding-system to encode the data with. */
4517 DEFUN ("choose-write-coding-system", Fchoose_write_coding_system
,
4518 Schoose_write_coding_system
, 3, 6, 0,
4519 doc
: /* Choose the coding system for writing a file.
4520 Arguments are as for `write-region'.
4521 This function is for internal use only. It may prompt the user. */ )
4522 (Lisp_Object start
, Lisp_Object end
, Lisp_Object filename
,
4523 Lisp_Object append
, Lisp_Object visit
, Lisp_Object lockname
)
4526 Lisp_Object eol_parent
= Qnil
;
4528 /* Mimic write-region behavior. */
4531 XSETFASTINT (start
, BEGV
);
4532 XSETFASTINT (end
, ZV
);
4536 && NILP (Fstring_equal (BVAR (current_buffer
, filename
),
4537 BVAR (current_buffer
, auto_save_file_name
))))
4542 else if (!NILP (Vcoding_system_for_write
))
4544 val
= Vcoding_system_for_write
;
4545 if (coding_system_require_warning
4546 && !NILP (Ffboundp (Vselect_safe_coding_system_function
)))
4547 /* Confirm that VAL can surely encode the current region. */
4548 val
= call5 (Vselect_safe_coding_system_function
,
4549 start
, end
, list2 (Qt
, val
),
4554 /* If the variable `buffer-file-coding-system' is set locally,
4555 it means that the file was read with some kind of code
4556 conversion or the variable is explicitly set by users. We
4557 had better write it out with the same coding system even if
4558 `enable-multibyte-characters' is nil.
4560 If it is not set locally, we anyway have to convert EOL
4561 format if the default value of `buffer-file-coding-system'
4562 tells that it is not Unix-like (LF only) format. */
4563 bool using_default_coding
= 0;
4564 bool force_raw_text
= 0;
4566 val
= BVAR (current_buffer
, buffer_file_coding_system
);
4568 || NILP (Flocal_variable_p (Qbuffer_file_coding_system
, Qnil
)))
4571 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
4577 /* Check file-coding-system-alist. */
4578 Lisp_Object args
[7], coding_systems
;
4580 args
[0] = Qwrite_region
; args
[1] = start
; args
[2] = end
;
4581 args
[3] = filename
; args
[4] = append
; args
[5] = visit
;
4583 coding_systems
= Ffind_operation_coding_system (7, args
);
4584 if (CONSP (coding_systems
) && !NILP (XCDR (coding_systems
)))
4585 val
= XCDR (coding_systems
);
4590 /* If we still have not decided a coding system, use the
4591 default value of buffer-file-coding-system. */
4592 val
= BVAR (current_buffer
, buffer_file_coding_system
);
4593 using_default_coding
= 1;
4596 if (! NILP (val
) && ! force_raw_text
)
4598 Lisp_Object spec
, attrs
;
4600 CHECK_CODING_SYSTEM_GET_SPEC (val
, spec
);
4601 attrs
= AREF (spec
, 0);
4602 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
4607 && !NILP (Ffboundp (Vselect_safe_coding_system_function
)))
4608 /* Confirm that VAL can surely encode the current region. */
4609 val
= call5 (Vselect_safe_coding_system_function
,
4610 start
, end
, val
, Qnil
, filename
);
4612 /* If the decided coding-system doesn't specify end-of-line
4613 format, we use that of
4614 `default-buffer-file-coding-system'. */
4615 if (! using_default_coding
4616 && ! NILP (BVAR (&buffer_defaults
, buffer_file_coding_system
)))
4617 val
= (coding_inherit_eol_type
4618 (val
, BVAR (&buffer_defaults
, buffer_file_coding_system
)));
4620 /* If we decide not to encode text, use `raw-text' or one of its
4623 val
= raw_text_coding_system (val
);
4626 val
= coding_inherit_eol_type (val
, eol_parent
);
4630 DEFUN ("write-region", Fwrite_region
, Swrite_region
, 3, 7,
4631 "r\nFWrite region to file: \ni\ni\ni\np",
4632 doc
: /* Write current region into specified file.
4633 When called from a program, requires three arguments:
4634 START, END and FILENAME. START and END are normally buffer positions
4635 specifying the part of the buffer to write.
4636 If START is nil, that means to use the entire buffer contents.
4637 If START is a string, then output that string to the file
4638 instead of any buffer contents; END is ignored.
4640 Optional fourth argument APPEND if non-nil means
4641 append to existing file contents (if any). If it is a number,
4642 seek to that offset in the file before writing.
4643 Optional fifth argument VISIT, if t or a string, means
4644 set the last-save-file-modtime of buffer to this file's modtime
4645 and mark buffer not modified.
4646 If VISIT is a string, it is a second file name;
4647 the output goes to FILENAME, but the buffer is marked as visiting VISIT.
4648 VISIT is also the file name to lock and unlock for clash detection.
4649 If VISIT is neither t nor nil nor a string,
4650 that means do not display the \"Wrote file\" message.
4651 The optional sixth arg LOCKNAME, if non-nil, specifies the name to
4652 use for locking and unlocking, overriding FILENAME and VISIT.
4653 The optional seventh arg MUSTBENEW, if non-nil, insists on a check
4654 for an existing file with the same name. If MUSTBENEW is `excl',
4655 that means to get an error if the file already exists; never overwrite.
4656 If MUSTBENEW is neither nil nor `excl', that means ask for
4657 confirmation before overwriting, but do go ahead and overwrite the file
4658 if the user confirms.
4660 This does code conversion according to the value of
4661 `coding-system-for-write', `buffer-file-coding-system', or
4662 `file-coding-system-alist', and sets the variable
4663 `last-coding-system-used' to the coding system actually used.
4665 This calls `write-region-annotate-functions' at the start, and
4666 `write-region-post-annotation-function' at the end. */)
4667 (Lisp_Object start
, Lisp_Object end
, Lisp_Object filename
, Lisp_Object append
,
4668 Lisp_Object visit
, Lisp_Object lockname
, Lisp_Object mustbenew
)
4670 return write_region (start
, end
, filename
, append
, visit
, lockname
, mustbenew
,
4674 /* Like Fwrite_region, except that if DESC is nonnegative, it is a file
4675 descriptor for FILENAME, so do not open or close FILENAME. */
4678 write_region (Lisp_Object start
, Lisp_Object end
, Lisp_Object filename
,
4679 Lisp_Object append
, Lisp_Object visit
, Lisp_Object lockname
,
4680 Lisp_Object mustbenew
, int desc
)
4684 off_t offset
IF_LINT (= 0);
4685 bool open_and_close_file
= desc
< 0;
4690 struct timespec modtime
;
4691 ptrdiff_t count
= SPECPDL_INDEX ();
4692 ptrdiff_t count1
IF_LINT (= 0);
4693 Lisp_Object handler
;
4694 Lisp_Object visit_file
;
4695 Lisp_Object annotations
;
4696 Lisp_Object encoded_filename
;
4697 bool visiting
= (EQ (visit
, Qt
) || STRINGP (visit
));
4698 bool quietly
= !NILP (visit
);
4699 bool file_locked
= 0;
4700 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
4701 struct buffer
*given_buffer
;
4702 struct coding_system coding
;
4704 if (current_buffer
->base_buffer
&& visiting
)
4705 error ("Cannot do file visiting in an indirect buffer");
4707 if (!NILP (start
) && !STRINGP (start
))
4708 validate_region (&start
, &end
);
4711 GCPRO5 (start
, filename
, visit
, visit_file
, lockname
);
4713 filename
= Fexpand_file_name (filename
, Qnil
);
4715 if (!NILP (mustbenew
) && !EQ (mustbenew
, Qexcl
))
4716 barf_or_query_if_file_exists (filename
, "overwrite", 1, 0, 1);
4718 if (STRINGP (visit
))
4719 visit_file
= Fexpand_file_name (visit
, Qnil
);
4721 visit_file
= filename
;
4723 if (NILP (lockname
))
4724 lockname
= visit_file
;
4728 /* If the file name has special constructs in it,
4729 call the corresponding file handler. */
4730 handler
= Ffind_file_name_handler (filename
, Qwrite_region
);
4731 /* If FILENAME has no handler, see if VISIT has one. */
4732 if (NILP (handler
) && STRINGP (visit
))
4733 handler
= Ffind_file_name_handler (visit
, Qwrite_region
);
4735 if (!NILP (handler
))
4738 val
= call6 (handler
, Qwrite_region
, start
, end
,
4739 filename
, append
, visit
);
4743 SAVE_MODIFF
= MODIFF
;
4744 XSETFASTINT (BVAR (current_buffer
, save_length
), Z
- BEG
);
4745 bset_filename (current_buffer
, visit_file
);
4751 record_unwind_protect (save_restriction_restore
, save_restriction_save ());
4753 /* Special kludge to simplify auto-saving. */
4756 /* Do it later, so write-region-annotate-function can work differently
4757 if we save "the buffer" vs "a region".
4758 This is useful in tar-mode. --Stef
4759 XSETFASTINT (start, BEG);
4760 XSETFASTINT (end, Z); */
4764 record_unwind_protect (build_annotations_unwind
,
4765 Vwrite_region_annotation_buffers
);
4766 Vwrite_region_annotation_buffers
= list1 (Fcurrent_buffer ());
4768 given_buffer
= current_buffer
;
4770 if (!STRINGP (start
))
4772 annotations
= build_annotations (start
, end
);
4774 if (current_buffer
!= given_buffer
)
4776 XSETFASTINT (start
, BEGV
);
4777 XSETFASTINT (end
, ZV
);
4783 XSETFASTINT (start
, BEGV
);
4784 XSETFASTINT (end
, ZV
);
4789 GCPRO5 (start
, filename
, annotations
, visit_file
, lockname
);
4791 /* Decide the coding-system to encode the data with.
4792 We used to make this choice before calling build_annotations, but that
4793 leads to problems when a write-annotate-function takes care of
4794 unsavable chars (as was the case with X-Symbol). */
4795 Vlast_coding_system_used
=
4796 Fchoose_write_coding_system (start
, end
, filename
,
4797 append
, visit
, lockname
);
4799 setup_coding_system (Vlast_coding_system_used
, &coding
);
4801 if (!STRINGP (start
) && !NILP (BVAR (current_buffer
, selective_display
)))
4802 coding
.mode
|= CODING_MODE_SELECTIVE_DISPLAY
;
4804 #ifdef CLASH_DETECTION
4805 if (open_and_close_file
&& !auto_saving
)
4807 lock_file (lockname
);
4810 #endif /* CLASH_DETECTION */
4812 encoded_filename
= ENCODE_FILE (filename
);
4813 fn
= SSDATA (encoded_filename
);
4814 open_flags
= O_WRONLY
| O_BINARY
| O_CREAT
;
4815 open_flags
|= EQ (mustbenew
, Qexcl
) ? O_EXCL
: !NILP (append
) ? 0 : O_TRUNC
;
4816 if (NUMBERP (append
))
4817 offset
= file_offset (append
);
4818 else if (!NILP (append
))
4819 open_flags
|= O_APPEND
;
4821 mode
= S_IREAD
| S_IWRITE
;
4823 mode
= auto_saving
? auto_save_mode_bits
: 0666;
4826 if (open_and_close_file
)
4828 desc
= emacs_open (fn
, open_flags
, mode
);
4831 int open_errno
= errno
;
4832 #ifdef CLASH_DETECTION
4834 unlock_file (lockname
);
4835 #endif /* CLASH_DETECTION */
4837 report_file_errno ("Opening output file", filename
, open_errno
);
4840 count1
= SPECPDL_INDEX ();
4841 record_unwind_protect_int (close_file_unwind
, desc
);
4844 if (NUMBERP (append
))
4846 off_t ret
= lseek (desc
, offset
, SEEK_SET
);
4849 int lseek_errno
= errno
;
4850 #ifdef CLASH_DETECTION
4852 unlock_file (lockname
);
4853 #endif /* CLASH_DETECTION */
4855 report_file_errno ("Lseek error", filename
, lseek_errno
);
4863 if (STRINGP (start
))
4864 ok
= a_write (desc
, start
, 0, SCHARS (start
), &annotations
, &coding
);
4865 else if (XINT (start
) != XINT (end
))
4866 ok
= a_write (desc
, Qnil
, XINT (start
), XINT (end
) - XINT (start
),
4867 &annotations
, &coding
);
4870 /* If file was empty, still need to write the annotations. */
4871 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
4872 ok
= a_write (desc
, Qnil
, XINT (end
), 0, &annotations
, &coding
);
4876 if (ok
&& CODING_REQUIRE_FLUSHING (&coding
)
4877 && !(coding
.mode
& CODING_MODE_LAST_BLOCK
))
4879 /* We have to flush out a data. */
4880 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
4881 ok
= e_write (desc
, Qnil
, 1, 1, &coding
);
4887 /* fsync is not crucial for temporary files. Nor for auto-save
4888 files, since they might lose some work anyway. */
4889 if (open_and_close_file
&& !auto_saving
&& !write_region_inhibit_fsync
)
4891 /* Transfer data and metadata to disk, retrying if interrupted.
4892 fsync can report a write failure here, e.g., due to disk full
4893 under NFS. But ignore EINVAL, which means fsync is not
4894 supported on this file. */
4895 while (fsync (desc
) != 0)
4898 if (errno
!= EINVAL
)
4899 ok
= 0, save_errno
= errno
;
4904 modtime
= invalid_timespec ();
4907 if (fstat (desc
, &st
) == 0)
4908 modtime
= get_stat_mtime (&st
);
4910 ok
= 0, save_errno
= errno
;
4913 if (open_and_close_file
)
4915 /* NFS can report a write failure now. */
4916 if (emacs_close (desc
) < 0)
4917 ok
= 0, save_errno
= errno
;
4919 /* Discard the unwind protect for close_file_unwind. */
4920 specpdl_ptr
= specpdl
+ count1
;
4923 /* Some file systems have a bug where st_mtime is not updated
4924 properly after a write. For example, CIFS might not see the
4925 st_mtime change until after the file is opened again.
4927 Attempt to detect this file system bug, and update MODTIME to the
4928 newer st_mtime if the bug appears to be present. This introduces
4929 a race condition, so to avoid most instances of the race condition
4930 on non-buggy file systems, skip this check if the most recently
4931 encountered non-buggy file system was the current file system.
4933 A race condition can occur if some other process modifies the
4934 file between the fstat above and the fstat below, but the race is
4935 unlikely and a similar race between the last write and the fstat
4936 above cannot possibly be closed anyway. */
4938 if (timespec_valid_p (modtime
)
4939 && ! (valid_timestamp_file_system
&& st
.st_dev
== timestamp_file_system
))
4941 int desc1
= emacs_open (fn
, O_WRONLY
| O_BINARY
, 0);
4945 if (fstat (desc1
, &st1
) == 0
4946 && st
.st_dev
== st1
.st_dev
&& st
.st_ino
== st1
.st_ino
)
4948 /* Use the heuristic if it appears to be valid. With neither
4949 O_EXCL nor O_TRUNC, if Emacs happened to write nothing to the
4950 file, the time stamp won't change. Also, some non-POSIX
4951 systems don't update an empty file's time stamp when
4952 truncating it. Finally, file systems with 100 ns or worse
4953 resolution sometimes seem to have bugs: on a system with ns
4954 resolution, checking ns % 100 incorrectly avoids the heuristic
4955 1% of the time, but the problem should be temporary as we will
4956 try again on the next time stamp. */
4958 = ((open_flags
& (O_EXCL
| O_TRUNC
)) != 0
4960 && modtime
.tv_nsec
% 100 != 0);
4962 struct timespec modtime1
= get_stat_mtime (&st1
);
4964 && timespec_cmp (modtime
, modtime1
) == 0
4965 && st
.st_size
== st1
.st_size
)
4967 timestamp_file_system
= st
.st_dev
;
4968 valid_timestamp_file_system
= 1;
4972 st
.st_size
= st1
.st_size
;
4976 emacs_close (desc1
);
4980 /* Call write-region-post-annotation-function. */
4981 while (CONSP (Vwrite_region_annotation_buffers
))
4983 Lisp_Object buf
= XCAR (Vwrite_region_annotation_buffers
);
4984 if (!NILP (Fbuffer_live_p (buf
)))
4987 if (FUNCTIONP (Vwrite_region_post_annotation_function
))
4988 call0 (Vwrite_region_post_annotation_function
);
4990 Vwrite_region_annotation_buffers
4991 = XCDR (Vwrite_region_annotation_buffers
);
4994 unbind_to (count
, Qnil
);
4996 #ifdef CLASH_DETECTION
4998 unlock_file (lockname
);
4999 #endif /* CLASH_DETECTION */
5001 /* Do this before reporting IO error
5002 to avoid a "file has changed on disk" warning on
5003 next attempt to save. */
5004 if (timespec_valid_p (modtime
))
5006 current_buffer
->modtime
= modtime
;
5007 current_buffer
->modtime_size
= st
.st_size
;
5011 report_file_errno ("Write error", filename
, save_errno
);
5015 SAVE_MODIFF
= MODIFF
;
5016 XSETFASTINT (BVAR (current_buffer
, save_length
), Z
- BEG
);
5017 bset_filename (current_buffer
, visit_file
);
5018 update_mode_lines
= 14;
5023 && ! NILP (Fstring_equal (BVAR (current_buffer
, filename
),
5024 BVAR (current_buffer
, auto_save_file_name
))))
5025 SAVE_MODIFF
= MODIFF
;
5031 message_with_string ((NUMBERP (append
)
5041 DEFUN ("car-less-than-car", Fcar_less_than_car
, Scar_less_than_car
, 2, 2, 0,
5042 doc
: /* Return t if (car A) is numerically less than (car B). */)
5043 (Lisp_Object a
, Lisp_Object b
)
5045 Lisp_Object args
[2] = { Fcar (a
), Fcar (b
), };
5046 return Flss (2, args
);
5049 /* Build the complete list of annotations appropriate for writing out
5050 the text between START and END, by calling all the functions in
5051 write-region-annotate-functions and merging the lists they return.
5052 If one of these functions switches to a different buffer, we assume
5053 that buffer contains altered text. Therefore, the caller must
5054 make sure to restore the current buffer in all cases,
5055 as save-excursion would do. */
5058 build_annotations (Lisp_Object start
, Lisp_Object end
)
5060 Lisp_Object annotations
;
5062 struct gcpro gcpro1
, gcpro2
;
5063 Lisp_Object original_buffer
;
5065 bool used_global
= 0;
5067 XSETBUFFER (original_buffer
, current_buffer
);
5070 p
= Vwrite_region_annotate_functions
;
5071 GCPRO2 (annotations
, p
);
5074 struct buffer
*given_buffer
= current_buffer
;
5075 if (EQ (Qt
, XCAR (p
)) && !used_global
)
5076 { /* Use the global value of the hook. */
5079 arg
[0] = Fdefault_value (Qwrite_region_annotate_functions
);
5081 p
= Fappend (2, arg
);
5084 Vwrite_region_annotations_so_far
= annotations
;
5085 res
= call2 (XCAR (p
), start
, end
);
5086 /* If the function makes a different buffer current,
5087 assume that means this buffer contains altered text to be output.
5088 Reset START and END from the buffer bounds
5089 and discard all previous annotations because they should have
5090 been dealt with by this function. */
5091 if (current_buffer
!= given_buffer
)
5093 Vwrite_region_annotation_buffers
5094 = Fcons (Fcurrent_buffer (),
5095 Vwrite_region_annotation_buffers
);
5096 XSETFASTINT (start
, BEGV
);
5097 XSETFASTINT (end
, ZV
);
5100 Flength (res
); /* Check basic validity of return value */
5101 annotations
= merge (annotations
, res
, Qcar_less_than_car
);
5105 /* Now do the same for annotation functions implied by the file-format */
5106 if (auto_saving
&& (!EQ (BVAR (current_buffer
, auto_save_file_format
), Qt
)))
5107 p
= BVAR (current_buffer
, auto_save_file_format
);
5109 p
= BVAR (current_buffer
, file_format
);
5110 for (i
= 0; CONSP (p
); p
= XCDR (p
), ++i
)
5112 struct buffer
*given_buffer
= current_buffer
;
5114 Vwrite_region_annotations_so_far
= annotations
;
5116 /* Value is either a list of annotations or nil if the function
5117 has written annotations to a temporary buffer, which is now
5119 res
= call5 (Qformat_annotate_function
, XCAR (p
), start
, end
,
5120 original_buffer
, make_number (i
));
5121 if (current_buffer
!= given_buffer
)
5123 XSETFASTINT (start
, BEGV
);
5124 XSETFASTINT (end
, ZV
);
5129 annotations
= merge (annotations
, res
, Qcar_less_than_car
);
5137 /* Write to descriptor DESC the NCHARS chars starting at POS of STRING.
5138 If STRING is nil, POS is the character position in the current buffer.
5139 Intersperse with them the annotations from *ANNOT
5140 which fall within the range of POS to POS + NCHARS,
5141 each at its appropriate position.
5143 We modify *ANNOT by discarding elements as we use them up.
5145 Return true if successful. */
5148 a_write (int desc
, Lisp_Object string
, ptrdiff_t pos
,
5149 ptrdiff_t nchars
, Lisp_Object
*annot
,
5150 struct coding_system
*coding
)
5154 ptrdiff_t lastpos
= pos
+ nchars
;
5156 while (NILP (*annot
) || CONSP (*annot
))
5158 tem
= Fcar_safe (Fcar (*annot
));
5161 nextpos
= XFASTINT (tem
);
5163 /* If there are no more annotations in this range,
5164 output the rest of the range all at once. */
5165 if (! (nextpos
>= pos
&& nextpos
<= lastpos
))
5166 return e_write (desc
, string
, pos
, lastpos
, coding
);
5168 /* Output buffer text up to the next annotation's position. */
5171 if (!e_write (desc
, string
, pos
, nextpos
, coding
))
5175 /* Output the annotation. */
5176 tem
= Fcdr (Fcar (*annot
));
5179 if (!e_write (desc
, tem
, 0, SCHARS (tem
), coding
))
5182 *annot
= Fcdr (*annot
);
5187 /* Maximum number of characters that the next
5188 function encodes per one loop iteration. */
5190 enum { E_WRITE_MAX
= 8 * 1024 * 1024 };
5192 /* Write text in the range START and END into descriptor DESC,
5193 encoding them with coding system CODING. If STRING is nil, START
5194 and END are character positions of the current buffer, else they
5195 are indexes to the string STRING. Return true if successful. */
5198 e_write (int desc
, Lisp_Object string
, ptrdiff_t start
, ptrdiff_t end
,
5199 struct coding_system
*coding
)
5201 if (STRINGP (string
))
5204 end
= SCHARS (string
);
5207 /* We used to have a code for handling selective display here. But,
5208 now it is handled within encode_coding. */
5212 if (STRINGP (string
))
5214 coding
->src_multibyte
= SCHARS (string
) < SBYTES (string
);
5215 if (CODING_REQUIRE_ENCODING (coding
))
5217 ptrdiff_t nchars
= min (end
- start
, E_WRITE_MAX
);
5219 /* Avoid creating huge Lisp string in encode_coding_object. */
5220 if (nchars
== E_WRITE_MAX
)
5221 coding
->raw_destination
= 1;
5223 encode_coding_object
5224 (coding
, string
, start
, string_char_to_byte (string
, start
),
5225 start
+ nchars
, string_char_to_byte (string
, start
+ nchars
),
5230 coding
->dst_object
= string
;
5231 coding
->consumed_char
= SCHARS (string
);
5232 coding
->produced
= SBYTES (string
);
5237 ptrdiff_t start_byte
= CHAR_TO_BYTE (start
);
5238 ptrdiff_t end_byte
= CHAR_TO_BYTE (end
);
5240 coding
->src_multibyte
= (end
- start
) < (end_byte
- start_byte
);
5241 if (CODING_REQUIRE_ENCODING (coding
))
5243 ptrdiff_t nchars
= min (end
- start
, E_WRITE_MAX
);
5246 if (nchars
== E_WRITE_MAX
)
5247 coding
->raw_destination
= 1;
5249 encode_coding_object
5250 (coding
, Fcurrent_buffer (), start
, start_byte
,
5251 start
+ nchars
, CHAR_TO_BYTE (start
+ nchars
), Qt
);
5255 coding
->dst_object
= Qnil
;
5256 coding
->dst_pos_byte
= start_byte
;
5257 if (start
>= GPT
|| end
<= GPT
)
5259 coding
->consumed_char
= end
- start
;
5260 coding
->produced
= end_byte
- start_byte
;
5264 coding
->consumed_char
= GPT
- start
;
5265 coding
->produced
= GPT_BYTE
- start_byte
;
5270 if (coding
->produced
> 0)
5272 char *buf
= (coding
->raw_destination
? (char *) coding
->destination
5273 : (STRINGP (coding
->dst_object
)
5274 ? SSDATA (coding
->dst_object
)
5275 : (char *) BYTE_POS_ADDR (coding
->dst_pos_byte
)));
5276 coding
->produced
-= emacs_write_sig (desc
, buf
, coding
->produced
);
5278 if (coding
->raw_destination
)
5280 /* We're responsible for freeing this, see
5281 encode_coding_object to check why. */
5282 xfree (coding
->destination
);
5283 coding
->raw_destination
= 0;
5285 if (coding
->produced
)
5288 start
+= coding
->consumed_char
;
5294 DEFUN ("verify-visited-file-modtime", Fverify_visited_file_modtime
,
5295 Sverify_visited_file_modtime
, 0, 1, 0,
5296 doc
: /* Return t if last mod time of BUF's visited file matches what BUF records.
5297 This means that the file has not been changed since it was visited or saved.
5298 If BUF is omitted or nil, it defaults to the current buffer.
5299 See Info node `(elisp)Modification Time' for more details. */)
5304 Lisp_Object handler
;
5305 Lisp_Object filename
;
5306 struct timespec mtime
;
5316 if (!STRINGP (BVAR (b
, filename
))) return Qt
;
5317 if (b
->modtime
.tv_nsec
== UNKNOWN_MODTIME_NSECS
) return Qt
;
5319 /* If the file name has special constructs in it,
5320 call the corresponding file handler. */
5321 handler
= Ffind_file_name_handler (BVAR (b
, filename
),
5322 Qverify_visited_file_modtime
);
5323 if (!NILP (handler
))
5324 return call2 (handler
, Qverify_visited_file_modtime
, buf
);
5326 filename
= ENCODE_FILE (BVAR (b
, filename
));
5328 mtime
= (stat (SSDATA (filename
), &st
) == 0
5329 ? get_stat_mtime (&st
)
5330 : time_error_value (errno
));
5331 if (timespec_cmp (mtime
, b
->modtime
) == 0
5332 && (b
->modtime_size
< 0
5333 || st
.st_size
== b
->modtime_size
))
5338 DEFUN ("visited-file-modtime", Fvisited_file_modtime
,
5339 Svisited_file_modtime
, 0, 0, 0,
5340 doc
: /* Return the current buffer's recorded visited file modification time.
5341 The value is a list of the form (HIGH LOW USEC PSEC), like the time values that
5342 `file-attributes' returns. If the current buffer has no recorded file
5343 modification time, this function returns 0. If the visited file
5344 doesn't exist, return -1.
5345 See Info node `(elisp)Modification Time' for more details. */)
5348 int ns
= current_buffer
->modtime
.tv_nsec
;
5350 return make_number (UNKNOWN_MODTIME_NSECS
- ns
);
5351 return make_lisp_time (current_buffer
->modtime
);
5354 DEFUN ("set-visited-file-modtime", Fset_visited_file_modtime
,
5355 Sset_visited_file_modtime
, 0, 1, 0,
5356 doc
: /* Update buffer's recorded modification time from the visited file's time.
5357 Useful if the buffer was not read from the file normally
5358 or if the file itself has been changed for some known benign reason.
5359 An argument specifies the modification time value to use
5360 \(instead of that of the visited file), in the form of a list
5361 \(HIGH LOW USEC PSEC) or an integer flag as returned by
5362 `visited-file-modtime'. */)
5363 (Lisp_Object time_flag
)
5365 if (!NILP (time_flag
))
5367 struct timespec mtime
;
5368 if (INTEGERP (time_flag
))
5370 CHECK_RANGED_INTEGER (time_flag
, -1, 0);
5371 mtime
= make_timespec (0, UNKNOWN_MODTIME_NSECS
- XINT (time_flag
));
5374 mtime
= lisp_time_argument (time_flag
);
5376 current_buffer
->modtime
= mtime
;
5377 current_buffer
->modtime_size
= -1;
5381 register Lisp_Object filename
;
5383 Lisp_Object handler
;
5385 filename
= Fexpand_file_name (BVAR (current_buffer
, filename
), Qnil
);
5387 /* If the file name has special constructs in it,
5388 call the corresponding file handler. */
5389 handler
= Ffind_file_name_handler (filename
, Qset_visited_file_modtime
);
5390 if (!NILP (handler
))
5391 /* The handler can find the file name the same way we did. */
5392 return call2 (handler
, Qset_visited_file_modtime
, Qnil
);
5394 filename
= ENCODE_FILE (filename
);
5396 if (stat (SSDATA (filename
), &st
) >= 0)
5398 current_buffer
->modtime
= get_stat_mtime (&st
);
5399 current_buffer
->modtime_size
= st
.st_size
;
5407 auto_save_error (Lisp_Object error_val
)
5409 Lisp_Object args
[3], msg
;
5411 struct gcpro gcpro1
;
5413 auto_save_error_occurred
= 1;
5415 ring_bell (XFRAME (selected_frame
));
5417 args
[0] = build_string ("Auto-saving %s: %s");
5418 args
[1] = BVAR (current_buffer
, name
);
5419 args
[2] = Ferror_message_string (error_val
);
5420 msg
= Fformat (3, args
);
5423 for (i
= 0; i
< 3; ++i
)
5428 message3_nolog (msg
);
5429 Fsleep_for (make_number (1), Qnil
);
5442 auto_save_mode_bits
= 0666;
5444 /* Get visited file's mode to become the auto save file's mode. */
5445 if (! NILP (BVAR (current_buffer
, filename
)))
5447 if (stat (SSDATA (BVAR (current_buffer
, filename
)), &st
) >= 0)
5448 /* But make sure we can overwrite it later! */
5449 auto_save_mode_bits
= (st
.st_mode
| 0600) & 0777;
5450 else if (modes
= Ffile_modes (BVAR (current_buffer
, filename
)),
5452 /* Remote files don't cooperate with stat. */
5453 auto_save_mode_bits
= (XINT (modes
) | 0600) & 0777;
5457 Fwrite_region (Qnil
, Qnil
, BVAR (current_buffer
, auto_save_file_name
), Qnil
,
5458 NILP (Vauto_save_visited_file_name
) ? Qlambda
: Qt
,
5462 struct auto_save_unwind
5469 do_auto_save_unwind (void *arg
)
5471 struct auto_save_unwind
*p
= arg
;
5472 FILE *stream
= p
->stream
;
5473 minibuffer_auto_raise
= p
->auto_raise
;
5484 do_auto_save_make_dir (Lisp_Object dir
)
5488 auto_saving_dir_umask
= 077;
5489 result
= call2 (Qmake_directory
, dir
, Qt
);
5490 auto_saving_dir_umask
= 0;
5495 do_auto_save_eh (Lisp_Object ignore
)
5497 auto_saving_dir_umask
= 0;
5501 DEFUN ("do-auto-save", Fdo_auto_save
, Sdo_auto_save
, 0, 2, "",
5502 doc
: /* Auto-save all buffers that need it.
5503 This is all buffers that have auto-saving enabled
5504 and are changed since last auto-saved.
5505 Auto-saving writes the buffer into a file
5506 so that your editing is not lost if the system crashes.
5507 This file is not the file you visited; that changes only when you save.
5508 Normally we run the normal hook `auto-save-hook' before saving.
5510 A non-nil NO-MESSAGE argument means do not print any message if successful.
5511 A non-nil CURRENT-ONLY argument means save only current buffer. */)
5512 (Lisp_Object no_message
, Lisp_Object current_only
)
5514 struct buffer
*old
= current_buffer
, *b
;
5515 Lisp_Object tail
, buf
, hook
;
5516 bool auto_saved
= 0;
5517 int do_handled_files
;
5519 FILE *stream
= NULL
;
5520 ptrdiff_t count
= SPECPDL_INDEX ();
5521 bool orig_minibuffer_auto_raise
= minibuffer_auto_raise
;
5522 bool old_message_p
= 0;
5523 struct auto_save_unwind auto_save_unwind
;
5524 struct gcpro gcpro1
, gcpro2
;
5526 if (max_specpdl_size
< specpdl_size
+ 40)
5527 max_specpdl_size
= specpdl_size
+ 40;
5532 if (NILP (no_message
))
5534 old_message_p
= push_message ();
5535 record_unwind_protect_void (pop_message_unwind
);
5538 /* Ordinarily don't quit within this function,
5539 but don't make it impossible to quit (in case we get hung in I/O). */
5543 /* No GCPRO needed, because (when it matters) all Lisp_Object variables
5544 point to non-strings reached from Vbuffer_alist. */
5546 hook
= intern ("auto-save-hook");
5547 safe_run_hooks (hook
);
5549 if (STRINGP (Vauto_save_list_file_name
))
5551 Lisp_Object listfile
;
5553 listfile
= Fexpand_file_name (Vauto_save_list_file_name
, Qnil
);
5555 /* Don't try to create the directory when shutting down Emacs,
5556 because creating the directory might signal an error, and
5557 that would leave Emacs in a strange state. */
5558 if (!NILP (Vrun_hooks
))
5562 GCPRO2 (dir
, listfile
);
5563 dir
= Ffile_name_directory (listfile
);
5564 if (NILP (Ffile_directory_p (dir
)))
5565 internal_condition_case_1 (do_auto_save_make_dir
,
5571 stream
= emacs_fopen (SSDATA (listfile
), "w");
5574 auto_save_unwind
.stream
= stream
;
5575 auto_save_unwind
.auto_raise
= minibuffer_auto_raise
;
5576 record_unwind_protect_ptr (do_auto_save_unwind
, &auto_save_unwind
);
5577 minibuffer_auto_raise
= 0;
5579 auto_save_error_occurred
= 0;
5581 /* On first pass, save all files that don't have handlers.
5582 On second pass, save all files that do have handlers.
5584 If Emacs is crashing, the handlers may tweak what is causing
5585 Emacs to crash in the first place, and it would be a shame if
5586 Emacs failed to autosave perfectly ordinary files because it
5587 couldn't handle some ange-ftp'd file. */
5589 for (do_handled_files
= 0; do_handled_files
< 2; do_handled_files
++)
5590 FOR_EACH_LIVE_BUFFER (tail
, buf
)
5594 /* Record all the buffers that have auto save mode
5595 in the special file that lists them. For each of these buffers,
5596 Record visited name (if any) and auto save name. */
5597 if (STRINGP (BVAR (b
, auto_save_file_name
))
5598 && stream
!= NULL
&& do_handled_files
== 0)
5601 if (!NILP (BVAR (b
, filename
)))
5603 fwrite (SDATA (BVAR (b
, filename
)), 1,
5604 SBYTES (BVAR (b
, filename
)), stream
);
5606 putc ('\n', stream
);
5607 fwrite (SDATA (BVAR (b
, auto_save_file_name
)), 1,
5608 SBYTES (BVAR (b
, auto_save_file_name
)), stream
);
5609 putc ('\n', stream
);
5613 if (!NILP (current_only
)
5614 && b
!= current_buffer
)
5617 /* Don't auto-save indirect buffers.
5618 The base buffer takes care of it. */
5622 /* Check for auto save enabled
5623 and file changed since last auto save
5624 and file changed since last real save. */
5625 if (STRINGP (BVAR (b
, auto_save_file_name
))
5626 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
5627 && BUF_AUTOSAVE_MODIFF (b
) < BUF_MODIFF (b
)
5628 /* -1 means we've turned off autosaving for a while--see below. */
5629 && XINT (BVAR (b
, save_length
)) >= 0
5630 && (do_handled_files
5631 || NILP (Ffind_file_name_handler (BVAR (b
, auto_save_file_name
),
5634 struct timespec before_time
= current_timespec ();
5635 struct timespec after_time
;
5637 /* If we had a failure, don't try again for 20 minutes. */
5638 if (b
->auto_save_failure_time
> 0
5639 && before_time
.tv_sec
- b
->auto_save_failure_time
< 1200)
5642 set_buffer_internal (b
);
5643 if (NILP (Vauto_save_include_big_deletions
)
5644 && (XFASTINT (BVAR (b
, save_length
)) * 10
5645 > (BUF_Z (b
) - BUF_BEG (b
)) * 13)
5646 /* A short file is likely to change a large fraction;
5647 spare the user annoying messages. */
5648 && XFASTINT (BVAR (b
, save_length
)) > 5000
5649 /* These messages are frequent and annoying for `*mail*'. */
5650 && !EQ (BVAR (b
, filename
), Qnil
)
5651 && NILP (no_message
))
5653 /* It has shrunk too much; turn off auto-saving here. */
5654 minibuffer_auto_raise
= orig_minibuffer_auto_raise
;
5655 message_with_string ("Buffer %s has shrunk a lot; auto save disabled in that buffer until next real save",
5657 minibuffer_auto_raise
= 0;
5658 /* Turn off auto-saving until there's a real save,
5659 and prevent any more warnings. */
5660 XSETINT (BVAR (b
, save_length
), -1);
5661 Fsleep_for (make_number (1), Qnil
);
5664 if (!auto_saved
&& NILP (no_message
))
5665 message1 ("Auto-saving...");
5666 internal_condition_case (auto_save_1
, Qt
, auto_save_error
);
5668 BUF_AUTOSAVE_MODIFF (b
) = BUF_MODIFF (b
);
5669 XSETFASTINT (BVAR (current_buffer
, save_length
), Z
- BEG
);
5670 set_buffer_internal (old
);
5672 after_time
= current_timespec ();
5674 /* If auto-save took more than 60 seconds,
5675 assume it was an NFS failure that got a timeout. */
5676 if (after_time
.tv_sec
- before_time
.tv_sec
> 60)
5677 b
->auto_save_failure_time
= after_time
.tv_sec
;
5681 /* Prevent another auto save till enough input events come in. */
5682 record_auto_save ();
5684 if (auto_saved
&& NILP (no_message
))
5688 /* If we are going to restore an old message,
5689 give time to read ours. */
5690 sit_for (make_number (1), 0, 0);
5693 else if (!auto_save_error_occurred
)
5694 /* Don't overwrite the error message if an error occurred.
5695 If we displayed a message and then restored a state
5696 with no message, leave a "done" message on the screen. */
5697 message1 ("Auto-saving...done");
5702 /* This restores the message-stack status. */
5703 unbind_to (count
, Qnil
);
5707 DEFUN ("set-buffer-auto-saved", Fset_buffer_auto_saved
,
5708 Sset_buffer_auto_saved
, 0, 0, 0,
5709 doc
: /* Mark current buffer as auto-saved with its current text.
5710 No auto-save file will be written until the buffer changes again. */)
5713 /* FIXME: This should not be called in indirect buffers, since
5714 they're not autosaved. */
5715 BUF_AUTOSAVE_MODIFF (current_buffer
) = MODIFF
;
5716 XSETFASTINT (BVAR (current_buffer
, save_length
), Z
- BEG
);
5717 current_buffer
->auto_save_failure_time
= 0;
5721 DEFUN ("clear-buffer-auto-save-failure", Fclear_buffer_auto_save_failure
,
5722 Sclear_buffer_auto_save_failure
, 0, 0, 0,
5723 doc
: /* Clear any record of a recent auto-save failure in the current buffer. */)
5726 current_buffer
->auto_save_failure_time
= 0;
5730 DEFUN ("recent-auto-save-p", Frecent_auto_save_p
, Srecent_auto_save_p
,
5732 doc
: /* Return t if current buffer has been auto-saved recently.
5733 More precisely, if it has been auto-saved since last read from or saved
5734 in the visited file. If the buffer has no visited file,
5735 then any auto-save counts as "recent". */)
5738 /* FIXME: maybe we should return nil for indirect buffers since
5739 they're never autosaved. */
5740 return (SAVE_MODIFF
< BUF_AUTOSAVE_MODIFF (current_buffer
) ? Qt
: Qnil
);
5743 /* Reading and completing file names */
5745 DEFUN ("next-read-file-uses-dialog-p", Fnext_read_file_uses_dialog_p
,
5746 Snext_read_file_uses_dialog_p
, 0, 0, 0,
5747 doc
: /* Return t if a call to `read-file-name' will use a dialog.
5748 The return value is only relevant for a call to `read-file-name' that happens
5749 before any other event (mouse or keypress) is handled. */)
5752 #if defined (USE_MOTIF) || defined (HAVE_NTGUI) || defined (USE_GTK) \
5753 || defined (HAVE_NS)
5754 if ((NILP (last_nonmenu_event
) || CONSP (last_nonmenu_event
))
5757 && window_system_available (SELECTED_FRAME ()))
5764 Fread_file_name (Lisp_Object prompt
, Lisp_Object dir
, Lisp_Object default_filename
, Lisp_Object mustmatch
, Lisp_Object initial
, Lisp_Object predicate
)
5766 struct gcpro gcpro1
;
5767 Lisp_Object args
[7];
5769 GCPRO1 (default_filename
);
5770 args
[0] = intern ("read-file-name");
5773 args
[3] = default_filename
;
5774 args
[4] = mustmatch
;
5776 args
[6] = predicate
;
5777 RETURN_UNGCPRO (Ffuncall (7, args
));
5784 valid_timestamp_file_system
= 0;
5788 syms_of_fileio (void)
5790 DEFSYM (Qoperations
, "operations");
5791 DEFSYM (Qexpand_file_name
, "expand-file-name");
5792 DEFSYM (Qsubstitute_in_file_name
, "substitute-in-file-name");
5793 DEFSYM (Qdirectory_file_name
, "directory-file-name");
5794 DEFSYM (Qfile_name_directory
, "file-name-directory");
5795 DEFSYM (Qfile_name_nondirectory
, "file-name-nondirectory");
5796 DEFSYM (Qunhandled_file_name_directory
, "unhandled-file-name-directory");
5797 DEFSYM (Qfile_name_as_directory
, "file-name-as-directory");
5798 DEFSYM (Qcopy_file
, "copy-file");
5799 DEFSYM (Qmake_directory_internal
, "make-directory-internal");
5800 DEFSYM (Qmake_directory
, "make-directory");
5801 DEFSYM (Qdelete_directory_internal
, "delete-directory-internal");
5802 DEFSYM (Qdelete_file
, "delete-file");
5803 DEFSYM (Qrename_file
, "rename-file");
5804 DEFSYM (Qadd_name_to_file
, "add-name-to-file");
5805 DEFSYM (Qmake_symbolic_link
, "make-symbolic-link");
5806 DEFSYM (Qfile_exists_p
, "file-exists-p");
5807 DEFSYM (Qfile_executable_p
, "file-executable-p");
5808 DEFSYM (Qfile_readable_p
, "file-readable-p");
5809 DEFSYM (Qfile_writable_p
, "file-writable-p");
5810 DEFSYM (Qfile_symlink_p
, "file-symlink-p");
5811 DEFSYM (Qaccess_file
, "access-file");
5812 DEFSYM (Qfile_directory_p
, "file-directory-p");
5813 DEFSYM (Qfile_regular_p
, "file-regular-p");
5814 DEFSYM (Qfile_accessible_directory_p
, "file-accessible-directory-p");
5815 DEFSYM (Qfile_modes
, "file-modes");
5816 DEFSYM (Qset_file_modes
, "set-file-modes");
5817 DEFSYM (Qset_file_times
, "set-file-times");
5818 DEFSYM (Qfile_selinux_context
, "file-selinux-context");
5819 DEFSYM (Qset_file_selinux_context
, "set-file-selinux-context");
5820 DEFSYM (Qfile_acl
, "file-acl");
5821 DEFSYM (Qset_file_acl
, "set-file-acl");
5822 DEFSYM (Qfile_newer_than_file_p
, "file-newer-than-file-p");
5823 DEFSYM (Qinsert_file_contents
, "insert-file-contents");
5824 DEFSYM (Qchoose_write_coding_system
, "choose-write-coding-system");
5825 DEFSYM (Qwrite_region
, "write-region");
5826 DEFSYM (Qverify_visited_file_modtime
, "verify-visited-file-modtime");
5827 DEFSYM (Qset_visited_file_modtime
, "set-visited-file-modtime");
5828 DEFSYM (Qauto_save_coding
, "auto-save-coding");
5830 DEFSYM (Qfile_name_history
, "file-name-history");
5831 Fset (Qfile_name_history
, Qnil
);
5833 DEFSYM (Qfile_error
, "file-error");
5834 DEFSYM (Qfile_already_exists
, "file-already-exists");
5835 DEFSYM (Qfile_date_error
, "file-date-error");
5836 DEFSYM (Qfile_notify_error
, "file-notify-error");
5837 DEFSYM (Qexcl
, "excl");
5839 DEFVAR_LISP ("file-name-coding-system", Vfile_name_coding_system
,
5840 doc
: /* Coding system for encoding file names.
5841 If it is nil, `default-file-name-coding-system' (which see) is used. */);
5842 Vfile_name_coding_system
= Qnil
;
5844 DEFVAR_LISP ("default-file-name-coding-system",
5845 Vdefault_file_name_coding_system
,
5846 doc
: /* Default coding system for encoding file names.
5847 This variable is used only when `file-name-coding-system' is nil.
5849 This variable is set/changed by the command `set-language-environment'.
5850 User should not set this variable manually,
5851 instead use `file-name-coding-system' to get a constant encoding
5852 of file names regardless of the current language environment. */);
5853 Vdefault_file_name_coding_system
= Qnil
;
5855 DEFSYM (Qformat_decode
, "format-decode");
5856 DEFSYM (Qformat_annotate_function
, "format-annotate-function");
5857 DEFSYM (Qafter_insert_file_set_coding
, "after-insert-file-set-coding");
5858 DEFSYM (Qcar_less_than_car
, "car-less-than-car");
5860 Fput (Qfile_error
, Qerror_conditions
,
5861 Fpurecopy (list2 (Qfile_error
, Qerror
)));
5862 Fput (Qfile_error
, Qerror_message
,
5863 build_pure_c_string ("File error"));
5865 Fput (Qfile_already_exists
, Qerror_conditions
,
5866 Fpurecopy (list3 (Qfile_already_exists
, Qfile_error
, Qerror
)));
5867 Fput (Qfile_already_exists
, Qerror_message
,
5868 build_pure_c_string ("File already exists"));
5870 Fput (Qfile_date_error
, Qerror_conditions
,
5871 Fpurecopy (list3 (Qfile_date_error
, Qfile_error
, Qerror
)));
5872 Fput (Qfile_date_error
, Qerror_message
,
5873 build_pure_c_string ("Cannot set file date"));
5875 Fput (Qfile_notify_error
, Qerror_conditions
,
5876 Fpurecopy (list3 (Qfile_notify_error
, Qfile_error
, Qerror
)));
5877 Fput (Qfile_notify_error
, Qerror_message
,
5878 build_pure_c_string ("File notification error"));
5880 DEFVAR_LISP ("file-name-handler-alist", Vfile_name_handler_alist
,
5881 doc
: /* Alist of elements (REGEXP . HANDLER) for file names handled specially.
5882 If a file name matches REGEXP, all I/O on that file is done by calling
5883 HANDLER. If a file name matches more than one handler, the handler
5884 whose match starts last in the file name gets precedence. The
5885 function `find-file-name-handler' checks this list for a handler for
5888 HANDLER should be a function. The first argument given to it is the
5889 name of the I/O primitive to be handled; the remaining arguments are
5890 the arguments that were passed to that primitive. For example, if you
5891 do (file-exists-p FILENAME) and FILENAME is handled by HANDLER, then
5892 HANDLER is called like this:
5894 (funcall HANDLER 'file-exists-p FILENAME)
5896 Note that HANDLER must be able to handle all I/O primitives; if it has
5897 nothing special to do for a primitive, it should reinvoke the
5898 primitive to handle the operation \"the usual way\".
5899 See Info node `(elisp)Magic File Names' for more details. */);
5900 Vfile_name_handler_alist
= Qnil
;
5902 DEFVAR_LISP ("set-auto-coding-function",
5903 Vset_auto_coding_function
,
5904 doc
: /* If non-nil, a function to call to decide a coding system of file.
5905 Two arguments are passed to this function: the file name
5906 and the length of a file contents following the point.
5907 This function should return a coding system to decode the file contents.
5908 It should check the file name against `auto-coding-alist'.
5909 If no coding system is decided, it should check a coding system
5910 specified in the heading lines with the format:
5911 -*- ... coding: CODING-SYSTEM; ... -*-
5912 or local variable spec of the tailing lines with `coding:' tag. */);
5913 Vset_auto_coding_function
= Qnil
;
5915 DEFVAR_LISP ("after-insert-file-functions", Vafter_insert_file_functions
,
5916 doc
: /* A list of functions to be called at the end of `insert-file-contents'.
5917 Each is passed one argument, the number of characters inserted,
5918 with point at the start of the inserted text. Each function
5919 should leave point the same, and return the new character count.
5920 If `insert-file-contents' is intercepted by a handler from
5921 `file-name-handler-alist', that handler is responsible for calling the
5922 functions in `after-insert-file-functions' if appropriate. */);
5923 Vafter_insert_file_functions
= Qnil
;
5925 DEFVAR_LISP ("write-region-annotate-functions", Vwrite_region_annotate_functions
,
5926 doc
: /* A list of functions to be called at the start of `write-region'.
5927 Each is passed two arguments, START and END as for `write-region'.
5928 These are usually two numbers but not always; see the documentation
5929 for `write-region'. The function should return a list of pairs
5930 of the form (POSITION . STRING), consisting of strings to be effectively
5931 inserted at the specified positions of the file being written (1 means to
5932 insert before the first byte written). The POSITIONs must be sorted into
5935 If there are several annotation functions, the lists returned by these
5936 functions are merged destructively. As each annotation function runs,
5937 the variable `write-region-annotations-so-far' contains a list of all
5938 annotations returned by previous annotation functions.
5940 An annotation function can return with a different buffer current.
5941 Doing so removes the annotations returned by previous functions, and
5942 resets START and END to `point-min' and `point-max' of the new buffer.
5944 After `write-region' completes, Emacs calls the function stored in
5945 `write-region-post-annotation-function', once for each buffer that was
5946 current when building the annotations (i.e., at least once), with that
5947 buffer current. */);
5948 Vwrite_region_annotate_functions
= Qnil
;
5949 DEFSYM (Qwrite_region_annotate_functions
, "write-region-annotate-functions");
5951 DEFVAR_LISP ("write-region-post-annotation-function",
5952 Vwrite_region_post_annotation_function
,
5953 doc
: /* Function to call after `write-region' completes.
5954 The function is called with no arguments. If one or more of the
5955 annotation functions in `write-region-annotate-functions' changed the
5956 current buffer, the function stored in this variable is called for
5957 each of those additional buffers as well, in addition to the original
5958 buffer. The relevant buffer is current during each function call. */);
5959 Vwrite_region_post_annotation_function
= Qnil
;
5960 staticpro (&Vwrite_region_annotation_buffers
);
5962 DEFVAR_LISP ("write-region-annotations-so-far",
5963 Vwrite_region_annotations_so_far
,
5964 doc
: /* When an annotation function is called, this holds the previous annotations.
5965 These are the annotations made by other annotation functions
5966 that were already called. See also `write-region-annotate-functions'. */);
5967 Vwrite_region_annotations_so_far
= Qnil
;
5969 DEFVAR_LISP ("inhibit-file-name-handlers", Vinhibit_file_name_handlers
,
5970 doc
: /* A list of file name handlers that temporarily should not be used.
5971 This applies only to the operation `inhibit-file-name-operation'. */);
5972 Vinhibit_file_name_handlers
= Qnil
;
5974 DEFVAR_LISP ("inhibit-file-name-operation", Vinhibit_file_name_operation
,
5975 doc
: /* The operation for which `inhibit-file-name-handlers' is applicable. */);
5976 Vinhibit_file_name_operation
= Qnil
;
5978 DEFVAR_LISP ("auto-save-list-file-name", Vauto_save_list_file_name
,
5979 doc
: /* File name in which we write a list of all auto save file names.
5980 This variable is initialized automatically from `auto-save-list-file-prefix'
5981 shortly after Emacs reads your init file, if you have not yet given it
5982 a non-nil value. */);
5983 Vauto_save_list_file_name
= Qnil
;
5985 DEFVAR_LISP ("auto-save-visited-file-name", Vauto_save_visited_file_name
,
5986 doc
: /* Non-nil says auto-save a buffer in the file it is visiting, when practical.
5987 Normally auto-save files are written under other names. */);
5988 Vauto_save_visited_file_name
= Qnil
;
5990 DEFVAR_LISP ("auto-save-include-big-deletions", Vauto_save_include_big_deletions
,
5991 doc
: /* If non-nil, auto-save even if a large part of the text is deleted.
5992 If nil, deleting a substantial portion of the text disables auto-save
5993 in the buffer; this is the default behavior, because the auto-save
5994 file is usually more useful if it contains the deleted text. */);
5995 Vauto_save_include_big_deletions
= Qnil
;
5997 /* fsync can be a significant performance hit. Often it doesn't
5998 suffice to make the file-save operation survive a crash. For
5999 batch scripts, which are typically part of larger shell commands
6000 that don't fsync other files, its effect on performance can be
6001 significant so its utility is particularly questionable.
6002 Hence, for now by default fsync is used only when interactive.
6004 For more on why fsync often fails to work on today's hardware, see:
6005 Zheng M et al. Understanding the robustness of SSDs under power fault.
6006 11th USENIX Conf. on File and Storage Technologies, 2013 (FAST '13), 271-84
6007 http://www.usenix.org/system/files/conference/fast13/fast13-final80.pdf
6009 For more on why fsync does not suffice even if it works properly, see:
6010 Roche X. Necessary step(s) to synchronize filename operations on disk.
6011 Austin Group Defect 672, 2013-03-19
6012 http://austingroupbugs.net/view.php?id=672 */
6013 DEFVAR_BOOL ("write-region-inhibit-fsync", write_region_inhibit_fsync
,
6014 doc
: /* Non-nil means don't call fsync in `write-region'.
6015 This variable affects calls to `write-region' as well as save commands.
6016 Setting this to nil may avoid data loss if the system loses power or
6017 the operating system crashes. */);
6018 write_region_inhibit_fsync
= noninteractive
;
6020 DEFVAR_BOOL ("delete-by-moving-to-trash", delete_by_moving_to_trash
,
6021 doc
: /* Specifies whether to use the system's trash can.
6022 When non-nil, certain file deletion commands use the function
6023 `move-file-to-trash' instead of deleting files outright.
6024 This includes interactive calls to `delete-file' and
6025 `delete-directory' and the Dired deletion commands. */);
6026 delete_by_moving_to_trash
= 0;
6027 Qdelete_by_moving_to_trash
= intern_c_string ("delete-by-moving-to-trash");
6029 DEFSYM (Qmove_file_to_trash
, "move-file-to-trash");
6030 DEFSYM (Qcopy_directory
, "copy-directory");
6031 DEFSYM (Qdelete_directory
, "delete-directory");
6032 DEFSYM (Qsubstitute_env_in_file_name
, "substitute-env-in-file-name");
6034 defsubr (&Sfind_file_name_handler
);
6035 defsubr (&Sfile_name_directory
);
6036 defsubr (&Sfile_name_nondirectory
);
6037 defsubr (&Sunhandled_file_name_directory
);
6038 defsubr (&Sfile_name_as_directory
);
6039 defsubr (&Sdirectory_file_name
);
6040 defsubr (&Smake_temp_name
);
6041 defsubr (&Sexpand_file_name
);
6042 defsubr (&Ssubstitute_in_file_name
);
6043 defsubr (&Scopy_file
);
6044 defsubr (&Smake_directory_internal
);
6045 defsubr (&Sdelete_directory_internal
);
6046 defsubr (&Sdelete_file
);
6047 defsubr (&Srename_file
);
6048 defsubr (&Sadd_name_to_file
);
6049 defsubr (&Smake_symbolic_link
);
6050 defsubr (&Sfile_name_absolute_p
);
6051 defsubr (&Sfile_exists_p
);
6052 defsubr (&Sfile_executable_p
);
6053 defsubr (&Sfile_readable_p
);
6054 defsubr (&Sfile_writable_p
);
6055 defsubr (&Saccess_file
);
6056 defsubr (&Sfile_symlink_p
);
6057 defsubr (&Sfile_directory_p
);
6058 defsubr (&Sfile_accessible_directory_p
);
6059 defsubr (&Sfile_regular_p
);
6060 defsubr (&Sfile_modes
);
6061 defsubr (&Sset_file_modes
);
6062 defsubr (&Sset_file_times
);
6063 defsubr (&Sfile_selinux_context
);
6064 defsubr (&Sfile_acl
);
6065 defsubr (&Sset_file_acl
);
6066 defsubr (&Sset_file_selinux_context
);
6067 defsubr (&Sset_default_file_modes
);
6068 defsubr (&Sdefault_file_modes
);
6069 defsubr (&Sfile_newer_than_file_p
);
6070 defsubr (&Sinsert_file_contents
);
6071 defsubr (&Schoose_write_coding_system
);
6072 defsubr (&Swrite_region
);
6073 defsubr (&Scar_less_than_car
);
6074 defsubr (&Sverify_visited_file_modtime
);
6075 defsubr (&Svisited_file_modtime
);
6076 defsubr (&Sset_visited_file_modtime
);
6077 defsubr (&Sdo_auto_save
);
6078 defsubr (&Sset_buffer_auto_saved
);
6079 defsubr (&Sclear_buffer_auto_save_failure
);
6080 defsubr (&Srecent_auto_save_p
);
6082 defsubr (&Snext_read_file_uses_dialog_p
);
6085 defsubr (&Sunix_sync
);