1 /* File IO for GNU Emacs.
3 Copyright (C) 1985-1988, 1993-2016 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 (at
10 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 #if USE_ACL && defined HAVE_ACL_SET_FILE
46 #include "composite.h"
47 #include "character.h"
51 #include "blockinput.h"
52 #include "region-cache.h"
60 #endif /* not WINDOWSNT */
64 #include <sys/param.h>
68 /* On Windows, drive letters must be alphabetic - on DOS, the Netware
69 redirector allows the six letters between 'Z' and 'a' as well. */
71 #define IS_DRIVE(x) ((x) >= 'A' && (x) <= 'z')
74 #define IS_DRIVE(x) c_isalpha (x)
76 /* Need to lower-case the drive letter, or else expanded
77 filenames will sometimes compare unequal, because
78 `expand-file-name' doesn't always down-case the drive letter. */
79 #define DRIVE_LETTER(x) c_tolower (x)
84 #include <allocator.h>
85 #include <careadlinkat.h>
86 #include <stat-time.h>
88 #include <binary-io.h>
96 /* True during writing of auto-save files. */
97 static bool auto_saving
;
99 /* Emacs's real umask. */
100 static mode_t realmask
;
102 /* Nonzero umask during creation of auto-save directories. */
103 static mode_t auto_saving_dir_umask
;
105 /* Set by auto_save_1 to mode of original file so Fwrite_region will create
106 a new file with the same mode as the original. */
107 static mode_t auto_save_mode_bits
;
109 /* Set by auto_save_1 if an error occurred during the last auto-save. */
110 static bool auto_save_error_occurred
;
112 /* If VALID_TIMESTAMP_FILE_SYSTEM, then TIMESTAMP_FILE_SYSTEM is the device
113 number of a file system where time stamps were observed to to work. */
114 static bool valid_timestamp_file_system
;
115 static dev_t timestamp_file_system
;
117 /* Each time an annotation function changes the buffer, the new buffer
119 static Lisp_Object Vwrite_region_annotation_buffers
;
121 static bool a_write (int, Lisp_Object
, ptrdiff_t, ptrdiff_t,
122 Lisp_Object
*, struct coding_system
*);
123 static bool e_write (int, Lisp_Object
, ptrdiff_t, ptrdiff_t,
124 struct coding_system
*);
127 /* Return true if FILENAME exists. */
130 check_existing (const char *filename
)
132 return faccessat (AT_FDCWD
, filename
, F_OK
, AT_EACCESS
) == 0;
135 /* Return true if file FILENAME exists and can be executed. */
138 check_executable (char *filename
)
140 return faccessat (AT_FDCWD
, filename
, X_OK
, AT_EACCESS
) == 0;
143 /* Return true if file FILENAME exists and can be accessed
144 according to AMODE, which should include W_OK.
145 On failure, return false and set errno. */
148 check_writable (const char *filename
, int amode
)
151 /* FIXME: an faccessat implementation should be added to the
152 DOS/Windows ports and this #ifdef branch should be removed. */
154 if (stat (filename
, &st
) < 0)
157 return (st
.st_mode
& S_IWRITE
|| S_ISDIR (st
.st_mode
));
158 #else /* not MSDOS */
159 bool res
= faccessat (AT_FDCWD
, filename
, amode
, AT_EACCESS
) == 0;
161 /* faccessat may have returned failure because Cygwin couldn't
162 determine the file's UID or GID; if so, we return success. */
165 int faccessat_errno
= errno
;
167 if (stat (filename
, &st
) < 0)
169 res
= (st
.st_uid
== -1 || st
.st_gid
== -1);
170 errno
= faccessat_errno
;
174 #endif /* not MSDOS */
177 /* Signal a file-access failure. STRING describes the failure,
178 NAME the file involved, and ERRORNO the errno value.
180 If NAME is neither null nor a pair, package it up as a singleton
181 list before reporting it; this saves report_file_errno's caller the
182 trouble of preserving errno before calling list1. */
185 report_file_errno (char const *string
, Lisp_Object name
, int errorno
)
187 Lisp_Object data
= CONSP (name
) || NILP (name
) ? name
: list1 (name
);
188 char *str
= emacs_strerror (errorno
);
189 AUTO_STRING (unibyte_str
, str
);
190 Lisp_Object errstring
191 = code_convert_string_norecord (unibyte_str
, Vlocale_coding_system
, 0);
192 Lisp_Object errdata
= Fcons (errstring
, data
);
194 if (errorno
== EEXIST
)
195 xsignal (Qfile_already_exists
, errdata
);
197 xsignal (Qfile_error
, Fcons (build_string (string
), errdata
));
200 /* Signal a file-access failure that set errno. STRING describes the
201 failure, NAME the file involved. When invoking this function, take
202 care to not use arguments such as build_string ("foo") that involve
203 side effects that may set errno. */
206 report_file_error (char const *string
, Lisp_Object name
)
208 report_file_errno (string
, name
, errno
);
211 /* Like report_file_error, but reports a file-notify-error instead. */
214 report_file_notify_error (const char *string
, Lisp_Object name
)
216 char *str
= emacs_strerror (errno
);
217 AUTO_STRING (unibyte_str
, str
);
218 Lisp_Object errstring
219 = code_convert_string_norecord (unibyte_str
, Vlocale_coding_system
, 0);
220 Lisp_Object data
= CONSP (name
) || NILP (name
) ? name
: list1 (name
);
221 Lisp_Object errdata
= Fcons (errstring
, data
);
223 xsignal (Qfile_notify_error
, Fcons (build_string (string
), errdata
));
227 close_file_unwind (int fd
)
233 fclose_unwind (void *arg
)
239 /* Restore point, having saved it as a marker. */
242 restore_point_unwind (Lisp_Object location
)
244 Fgoto_char (location
);
245 unchain_marker (XMARKER (location
));
249 DEFUN ("find-file-name-handler", Ffind_file_name_handler
,
250 Sfind_file_name_handler
, 2, 2, 0,
251 doc
: /* Return FILENAME's handler function for OPERATION, if it has one.
252 Otherwise, return nil.
253 A file name is handled if one of the regular expressions in
254 `file-name-handler-alist' matches it.
256 If OPERATION equals `inhibit-file-name-operation', then we ignore
257 any handlers that are members of `inhibit-file-name-handlers',
258 but we still do run any other handlers. This lets handlers
259 use the standard functions without calling themselves recursively. */)
260 (Lisp_Object filename
, Lisp_Object operation
)
262 /* This function must not munge the match data. */
263 Lisp_Object chain
, inhibited_handlers
, result
;
267 CHECK_STRING (filename
);
269 if (EQ (operation
, Vinhibit_file_name_operation
))
270 inhibited_handlers
= Vinhibit_file_name_handlers
;
272 inhibited_handlers
= Qnil
;
274 for (chain
= Vfile_name_handler_alist
; CONSP (chain
);
275 chain
= XCDR (chain
))
281 Lisp_Object string
= XCAR (elt
);
283 Lisp_Object handler
= XCDR (elt
);
284 Lisp_Object operations
= Qnil
;
286 if (SYMBOLP (handler
))
287 operations
= Fget (handler
, Qoperations
);
290 && (match_pos
= fast_string_match (string
, filename
)) > pos
291 && (NILP (operations
) || ! NILP (Fmemq (operation
, operations
))))
295 handler
= XCDR (elt
);
296 tem
= Fmemq (handler
, inhibited_handlers
);
310 DEFUN ("file-name-directory", Ffile_name_directory
, Sfile_name_directory
,
312 doc
: /* Return the directory component in file name FILENAME.
313 Return nil if FILENAME does not include a directory.
314 Otherwise return a directory name.
315 Given a Unix syntax file name, returns a string ending in slash. */)
316 (Lisp_Object filename
)
320 CHECK_STRING (filename
);
322 /* If the file name has special constructs in it,
323 call the corresponding file handler. */
324 handler
= Ffind_file_name_handler (filename
, Qfile_name_directory
);
327 Lisp_Object handled_name
= call2 (handler
, Qfile_name_directory
,
329 return STRINGP (handled_name
) ? handled_name
: Qnil
;
332 char *beg
= SSDATA (filename
);
333 char const *p
= beg
+ SBYTES (filename
);
335 while (p
!= beg
&& !IS_DIRECTORY_SEP (p
[-1])
337 /* only recognize drive specifier at the beginning */
339 /* handle the "/:d:foo" and "/:foo" cases correctly */
340 && ((p
== beg
+ 2 && !IS_DIRECTORY_SEP (*beg
))
341 || (p
== beg
+ 4 && IS_DIRECTORY_SEP (*beg
))))
348 /* Expansion of "c:" to drive and default directory. */
351 SAFE_ALLOCA_STRING (beg
, filename
);
352 p
= beg
+ (p
- SSDATA (filename
));
356 /* MAXPATHLEN+1 is guaranteed to be enough space for getdefdir. */
357 char *res
= alloca (MAXPATHLEN
+ 1);
360 if (p
== beg
+ 4 && IS_DIRECTORY_SEP (*beg
) && beg
[1] == ':')
362 memcpy (res
, beg
, 2);
367 if (getdefdir (c_toupper (*beg
) - 'A' + 1, r
))
369 size_t l
= strlen (res
);
371 if (l
> 3 || !IS_DIRECTORY_SEP (res
[l
- 1]))
374 p
= beg
+ strlen (beg
);
375 dostounix_filename (beg
);
376 tem_fn
= make_specified_string (beg
, -1, p
- beg
,
377 STRING_MULTIBYTE (filename
));
380 tem_fn
= make_specified_string (beg
- 2, -1, p
- beg
+ 2,
381 STRING_MULTIBYTE (filename
));
383 else if (STRING_MULTIBYTE (filename
))
385 tem_fn
= make_specified_string (beg
, -1, p
- beg
, 1);
386 dostounix_filename (SSDATA (tem_fn
));
388 if (!NILP (Vw32_downcase_file_names
))
389 tem_fn
= Fdowncase (tem_fn
);
394 dostounix_filename (beg
);
395 tem_fn
= make_specified_string (beg
, -1, p
- beg
, 0);
400 return make_specified_string (beg
, -1, p
- beg
, STRING_MULTIBYTE (filename
));
404 DEFUN ("file-name-nondirectory", Ffile_name_nondirectory
,
405 Sfile_name_nondirectory
, 1, 1, 0,
406 doc
: /* Return file name FILENAME sans its directory.
407 For example, in a Unix-syntax file name,
408 this is everything after the last slash,
409 or the entire name if it contains no slash. */)
410 (Lisp_Object filename
)
412 register const char *beg
, *p
, *end
;
415 CHECK_STRING (filename
);
417 /* If the file name has special constructs in it,
418 call the corresponding file handler. */
419 handler
= Ffind_file_name_handler (filename
, Qfile_name_nondirectory
);
422 Lisp_Object handled_name
= call2 (handler
, Qfile_name_nondirectory
,
424 if (STRINGP (handled_name
))
426 error ("Invalid handler in `file-name-handler-alist'");
429 beg
= SSDATA (filename
);
430 end
= p
= beg
+ SBYTES (filename
);
432 while (p
!= beg
&& !IS_DIRECTORY_SEP (p
[-1])
434 /* only recognize drive specifier at beginning */
436 /* handle the "/:d:foo" case correctly */
437 && (p
== beg
+ 2 || (p
== beg
+ 4 && IS_DIRECTORY_SEP (*beg
))))
442 return make_specified_string (p
, -1, end
- p
, STRING_MULTIBYTE (filename
));
445 DEFUN ("unhandled-file-name-directory", Funhandled_file_name_directory
,
446 Sunhandled_file_name_directory
, 1, 1, 0,
447 doc
: /* Return a directly usable directory name somehow associated with FILENAME.
448 A `directly usable' directory name is one that may be used without the
449 intervention of any file handler.
450 If FILENAME is a directly usable file itself, return
451 \(file-name-as-directory FILENAME).
452 If FILENAME refers to a file which is not accessible from a local process,
453 then this should return nil.
454 The `call-process' and `start-process' functions use this function to
455 get a current directory to run processes in. */)
456 (Lisp_Object filename
)
460 /* If the file name has special constructs in it,
461 call the corresponding file handler. */
462 handler
= Ffind_file_name_handler (filename
, Qunhandled_file_name_directory
);
465 Lisp_Object handled_name
= call2 (handler
, Qunhandled_file_name_directory
,
467 return STRINGP (handled_name
) ? handled_name
: Qnil
;
470 return Ffile_name_as_directory (filename
);
473 /* Maximum number of bytes that DST will be longer than SRC
474 in file_name_as_directory. This occurs when SRCLEN == 0. */
475 enum { file_name_as_directory_slop
= 2 };
477 /* Convert from file name SRC of length SRCLEN to directory name in
478 DST. MULTIBYTE non-zero means the file name in SRC is a multibyte
479 string. On UNIX, just make sure there is a terminating /. Return
480 the length of DST in bytes. */
483 file_name_as_directory (char *dst
, const char *src
, ptrdiff_t srclen
,
494 memcpy (dst
, src
, srclen
);
495 if (!IS_DIRECTORY_SEP (dst
[srclen
- 1]))
496 dst
[srclen
++] = DIRECTORY_SEP
;
499 dostounix_filename (dst
);
504 DEFUN ("file-name-as-directory", Ffile_name_as_directory
,
505 Sfile_name_as_directory
, 1, 1, 0,
506 doc
: /* Return a string representing the file name FILE interpreted as a directory.
507 This operation exists because a directory is also a file, but its name as
508 a directory is different from its name as a file.
509 The result can be used as the value of `default-directory'
510 or passed as second argument to `expand-file-name'.
511 For a Unix-syntax file name, just appends a slash. */)
516 Lisp_Object handler
, val
;
521 /* If the file name has special constructs in it,
522 call the corresponding file handler. */
523 handler
= Ffind_file_name_handler (file
, Qfile_name_as_directory
);
526 Lisp_Object handled_name
= call2 (handler
, Qfile_name_as_directory
,
528 if (STRINGP (handled_name
))
530 error ("Invalid handler in `file-name-handler-alist'");
534 if (!NILP (Vw32_downcase_file_names
))
535 file
= Fdowncase (file
);
537 buf
= SAFE_ALLOCA (SBYTES (file
) + file_name_as_directory_slop
+ 1);
538 length
= file_name_as_directory (buf
, SSDATA (file
), SBYTES (file
),
539 STRING_MULTIBYTE (file
));
540 val
= make_specified_string (buf
, -1, length
, STRING_MULTIBYTE (file
));
545 /* Convert from directory name SRC of length SRCLEN to file name in
546 DST. MULTIBYTE non-zero means the file name in SRC is a multibyte
547 string. On UNIX, just make sure there isn't a terminating /.
548 Return the length of DST in bytes. */
551 directory_file_name (char *dst
, char *src
, ptrdiff_t srclen
, bool multibyte
)
553 /* Process as Unix format: just remove any final slash.
554 But leave "/" and "//" unchanged. */
557 && !IS_ANY_SEP (src
[srclen
- 2])
559 && IS_DIRECTORY_SEP (src
[srclen
- 1])
560 && ! (srclen
== 2 && IS_DIRECTORY_SEP (src
[0])))
563 memcpy (dst
, src
, srclen
);
566 dostounix_filename (dst
);
571 DEFUN ("directory-file-name", Fdirectory_file_name
, Sdirectory_file_name
,
573 doc
: /* Returns the file name of the directory named DIRECTORY.
574 This is the name of the file that holds the data for the directory DIRECTORY.
575 This operation exists because a directory is also a file, but its name as
576 a directory is different from its name as a file.
577 In Unix-syntax, this function just removes the final slash. */)
578 (Lisp_Object directory
)
582 Lisp_Object handler
, val
;
585 CHECK_STRING (directory
);
587 /* If the file name has special constructs in it,
588 call the corresponding file handler. */
589 handler
= Ffind_file_name_handler (directory
, Qdirectory_file_name
);
592 Lisp_Object handled_name
= call2 (handler
, Qdirectory_file_name
,
594 if (STRINGP (handled_name
))
596 error ("Invalid handler in `file-name-handler-alist'");
600 if (!NILP (Vw32_downcase_file_names
))
601 directory
= Fdowncase (directory
);
603 buf
= SAFE_ALLOCA (SBYTES (directory
) + 1);
604 length
= directory_file_name (buf
, SSDATA (directory
), SBYTES (directory
),
605 STRING_MULTIBYTE (directory
));
606 val
= make_specified_string (buf
, -1, length
, STRING_MULTIBYTE (directory
));
611 static const char make_temp_name_tbl
[64] =
613 'A','B','C','D','E','F','G','H',
614 'I','J','K','L','M','N','O','P',
615 'Q','R','S','T','U','V','W','X',
616 'Y','Z','a','b','c','d','e','f',
617 'g','h','i','j','k','l','m','n',
618 'o','p','q','r','s','t','u','v',
619 'w','x','y','z','0','1','2','3',
620 '4','5','6','7','8','9','-','_'
623 static unsigned make_temp_name_count
, make_temp_name_count_initialized_p
;
625 /* Value is a temporary file name starting with PREFIX, a string.
627 The Emacs process number forms part of the result, so there is
628 no danger of generating a name being used by another process.
629 In addition, this function makes an attempt to choose a name
630 which has no existing file. To make this work, PREFIX should be
631 an absolute file name.
633 BASE64_P means add the pid as 3 characters in base64
634 encoding. In this case, 6 characters will be added to PREFIX to
635 form the file name. Otherwise, if Emacs is running on a system
636 with long file names, add the pid as a decimal number.
638 This function signals an error if no unique file name could be
642 make_temp_name (Lisp_Object prefix
, bool base64_p
)
644 Lisp_Object val
, encoded_prefix
;
648 char pidbuf
[INT_BUFSIZE_BOUND (printmax_t
)];
651 CHECK_STRING (prefix
);
653 /* VAL is created by adding 6 characters to PREFIX. The first
654 three are the PID of this process, in base 64, and the second
655 three are incremented if the file already exists. This ensures
656 262144 unique file names per PID per PREFIX. */
662 pidbuf
[0] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
663 pidbuf
[1] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
664 pidbuf
[2] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
669 #ifdef HAVE_LONG_FILE_NAMES
670 pidlen
= sprintf (pidbuf
, "%"pMd
, pid
);
672 pidbuf
[0] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
673 pidbuf
[1] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
674 pidbuf
[2] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
679 encoded_prefix
= ENCODE_FILE (prefix
);
680 len
= SBYTES (encoded_prefix
);
681 val
= make_uninit_string (len
+ 3 + pidlen
);
683 memcpy (data
, SSDATA (encoded_prefix
), len
);
686 memcpy (p
, pidbuf
, pidlen
);
689 /* Here we try to minimize useless stat'ing when this function is
690 invoked many times successively with the same PREFIX. We achieve
691 this by initializing count to a random value, and incrementing it
694 We don't want make-temp-name to be called while dumping,
695 because then make_temp_name_count_initialized_p would get set
696 and then make_temp_name_count would not be set when Emacs starts. */
698 if (!make_temp_name_count_initialized_p
)
700 make_temp_name_count
= time (NULL
);
701 make_temp_name_count_initialized_p
= 1;
706 unsigned num
= make_temp_name_count
;
708 p
[0] = make_temp_name_tbl
[num
& 63], num
>>= 6;
709 p
[1] = make_temp_name_tbl
[num
& 63], num
>>= 6;
710 p
[2] = make_temp_name_tbl
[num
& 63], num
>>= 6;
712 /* Poor man's congruential RN generator. Replace with
713 ++make_temp_name_count for debugging. */
714 make_temp_name_count
+= 25229;
715 make_temp_name_count
%= 225307;
717 if (!check_existing (data
))
719 /* We want to return only if errno is ENOENT. */
721 return DECODE_FILE (val
);
723 /* The error here is dubious, but there is little else we
724 can do. The alternatives are to return nil, which is
725 as bad as (and in many cases worse than) throwing the
726 error, or to ignore the error, which will likely result
727 in looping through 225307 stat's, which is not only
728 dog-slow, but also useless since eventually nil would
729 have to be returned anyway. */
730 report_file_error ("Cannot create temporary name for prefix",
738 DEFUN ("make-temp-name", Fmake_temp_name
, Smake_temp_name
, 1, 1, 0,
739 doc
: /* Generate temporary file name (string) starting with PREFIX (a string).
740 The Emacs process number forms part of the result, so there is no
741 danger of generating a name being used by another Emacs process
742 \(so long as only a single host can access the containing directory...).
744 This function tries to choose a name that has no existing file.
745 For this to work, PREFIX should be an absolute file name.
747 There is a race condition between calling `make-temp-name' and creating the
748 file, which opens all kinds of security holes. For that reason, you should
749 normally use `make-temp-file' instead. */)
752 return make_temp_name (prefix
, 0);
755 DEFUN ("expand-file-name", Fexpand_file_name
, Sexpand_file_name
, 1, 2, 0,
756 doc
: /* Convert filename NAME to absolute, and canonicalize it.
757 Second arg DEFAULT-DIRECTORY is directory to start with if NAME is relative
758 \(does not start with slash or tilde); both the directory name and
759 a directory's file name are accepted. If DEFAULT-DIRECTORY is nil or
760 missing, the current buffer's value of `default-directory' is used.
761 NAME should be a string that is a valid file name for the underlying
763 File name components that are `.' are removed, and
764 so are file name components followed by `..', along with the `..' itself;
765 note that these simplifications are done without checking the resulting
766 file names in the file system.
767 Multiple consecutive slashes are collapsed into a single slash,
768 except at the beginning of the file name when they are significant (e.g.,
769 UNC file names on MS-Windows.)
770 An initial `~/' expands to your home directory.
771 An initial `~USER/' expands to USER's home directory.
772 See also the function `substitute-in-file-name'.
774 For technical reasons, this function can return correct but
775 non-intuitive results for the root directory; for instance,
776 \(expand-file-name ".." "/") returns "/..". For this reason, use
777 \(directory-file-name (file-name-directory dirname)) to traverse a
778 filesystem tree, not (expand-file-name ".." dirname). */)
779 (Lisp_Object name
, Lisp_Object default_directory
)
781 /* These point to SDATA and need to be careful with string-relocation
782 during GC (via DECODE_FILE). */
786 const char *newdirlim
;
787 /* This should only point to alloca'd data. */
794 bool collapse_newdir
= true;
797 ptrdiff_t length
, nbytes
;
798 Lisp_Object handler
, result
, handled_name
;
805 /* If the file name has special constructs in it,
806 call the corresponding file handler. */
807 handler
= Ffind_file_name_handler (name
, Qexpand_file_name
);
810 handled_name
= call3 (handler
, Qexpand_file_name
,
811 name
, default_directory
);
812 if (STRINGP (handled_name
))
814 error ("Invalid handler in `file-name-handler-alist'");
818 /* Use the buffer's default-directory if DEFAULT_DIRECTORY is omitted. */
819 if (NILP (default_directory
))
820 default_directory
= BVAR (current_buffer
, directory
);
821 if (! STRINGP (default_directory
))
824 /* "/" is not considered a root directory on DOS_NT, so using "/"
825 here causes an infinite recursion in, e.g., the following:
827 (let (default-directory)
828 (expand-file-name "a"))
830 To avoid this, we set default_directory to the root of the
832 default_directory
= build_string (emacs_root_dir ());
834 default_directory
= build_string ("/");
838 if (!NILP (default_directory
))
840 handler
= Ffind_file_name_handler (default_directory
, Qexpand_file_name
);
843 handled_name
= call3 (handler
, Qexpand_file_name
,
844 name
, default_directory
);
845 if (STRINGP (handled_name
))
847 error ("Invalid handler in `file-name-handler-alist'");
852 char *o
= SSDATA (default_directory
);
854 /* Make sure DEFAULT_DIRECTORY is properly expanded.
855 It would be better to do this down below where we actually use
856 default_directory. Unfortunately, calling Fexpand_file_name recursively
857 could invoke GC, and the strings might be relocated. This would
858 be annoying because we have pointers into strings lying around
859 that would need adjusting, and people would add new pointers to
860 the code and forget to adjust them, resulting in intermittent bugs.
861 Putting this call here avoids all that crud.
863 The EQ test avoids infinite recursion. */
864 if (! NILP (default_directory
) && !EQ (default_directory
, name
)
865 /* Save time in some common cases - as long as default_directory
866 is not relative, it can be canonicalized with name below (if it
867 is needed at all) without requiring it to be expanded now. */
869 /* Detect MSDOS file names with drive specifiers. */
870 && ! (IS_DRIVE (o
[0]) && IS_DEVICE_SEP (o
[1])
871 && IS_DIRECTORY_SEP (o
[2]))
873 /* Detect Windows file names in UNC format. */
874 && ! (IS_DIRECTORY_SEP (o
[0]) && IS_DIRECTORY_SEP (o
[1]))
876 #else /* not DOS_NT */
877 /* Detect Unix absolute file names (/... alone is not absolute on
879 && ! (IS_DIRECTORY_SEP (o
[0]))
880 #endif /* not DOS_NT */
883 default_directory
= Fexpand_file_name (default_directory
, Qnil
);
886 multibyte
= STRING_MULTIBYTE (name
);
887 if (multibyte
!= STRING_MULTIBYTE (default_directory
))
891 unsigned char *p
= SDATA (name
);
893 while (*p
&& ASCII_CHAR_P (*p
))
897 /* NAME is a pure ASCII string, and DEFAULT_DIRECTORY is
898 unibyte. Do not convert DEFAULT_DIRECTORY to
899 multibyte; instead, convert NAME to a unibyte string,
900 so that the result of this function is also a unibyte
901 string. This is needed during bootstrapping and
902 dumping, when Emacs cannot decode file names, because
903 the locale environment is not set up. */
904 name
= make_unibyte_string (SSDATA (name
), SBYTES (name
));
908 default_directory
= string_to_multibyte (default_directory
);
912 name
= string_to_multibyte (name
);
918 if (!NILP (Vw32_downcase_file_names
))
919 default_directory
= Fdowncase (default_directory
);
922 /* Make a local copy of NAME to protect it from GC in DECODE_FILE below. */
923 SAFE_ALLOCA_STRING (nm
, name
);
924 nmlim
= nm
+ SBYTES (name
);
927 /* Note if special escape prefix is present, but remove for now. */
928 if (nm
[0] == '/' && nm
[1] == ':')
934 /* Find and remove drive specifier if present; this makes nm absolute
935 even if the rest of the name appears to be relative. Only look for
936 drive specifier at the beginning. */
937 if (IS_DRIVE (nm
[0]) && IS_DEVICE_SEP (nm
[1]))
939 drive
= (unsigned char) nm
[0];
944 /* If we see "c://somedir", we want to strip the first slash after the
945 colon when stripping the drive letter. Otherwise, this expands to
947 if (drive
&& IS_DIRECTORY_SEP (nm
[0]) && IS_DIRECTORY_SEP (nm
[1]))
950 /* Discard any previous drive specifier if nm is now in UNC format. */
951 if (IS_DIRECTORY_SEP (nm
[0]) && IS_DIRECTORY_SEP (nm
[1])
952 && !IS_DIRECTORY_SEP (nm
[2]))
954 #endif /* WINDOWSNT */
957 /* If nm is absolute, look for `/./' or `/../' or `//''sequences; if
958 none are found, we can probably return right away. We will avoid
959 allocating a new string if name is already fully expanded. */
961 IS_DIRECTORY_SEP (nm
[0])
963 && drive
&& !is_escaped
966 && (drive
|| IS_DIRECTORY_SEP (nm
[1])) && !is_escaped
970 /* If it turns out that the filename we want to return is just a
971 suffix of FILENAME, we don't need to go through and edit
972 things; we just need to construct a new string using data
973 starting at the middle of FILENAME. If we set LOSE, that
974 means we've discovered that we can't do that cool trick. */
980 /* Since we know the name is absolute, we can assume that each
981 element starts with a "/". */
983 /* "." and ".." are hairy. */
984 if (IS_DIRECTORY_SEP (p
[0])
986 && (IS_DIRECTORY_SEP (p
[2])
988 || (p
[2] == '.' && (IS_DIRECTORY_SEP (p
[3])
991 /* Replace multiple slashes with a single one, except
992 leave leading "//" alone. */
993 else if (IS_DIRECTORY_SEP (p
[0])
994 && IS_DIRECTORY_SEP (p
[1])
995 && (p
!= nm
|| IS_DIRECTORY_SEP (p
[2])))
1002 /* Make sure directories are all separated with /, but
1003 avoid allocation of a new string when not required. */
1004 dostounix_filename (nm
);
1006 if (IS_DIRECTORY_SEP (nm
[1]))
1008 if (strcmp (nm
, SSDATA (name
)) != 0)
1009 name
= make_specified_string (nm
, -1, nmlim
- nm
, multibyte
);
1013 /* Drive must be set, so this is okay. */
1014 if (strcmp (nm
- 2, SSDATA (name
)) != 0)
1016 name
= make_specified_string (nm
, -1, p
- nm
, multibyte
);
1017 char temp
[] = { DRIVE_LETTER (drive
), ':', 0 };
1018 AUTO_STRING_WITH_LEN (drive_prefix
, temp
, 2);
1019 name
= concat2 (drive_prefix
, name
);
1022 if (!NILP (Vw32_downcase_file_names
))
1023 name
= Fdowncase (name
);
1025 #else /* not DOS_NT */
1026 if (strcmp (nm
, SSDATA (name
)) != 0)
1027 name
= make_specified_string (nm
, -1, nmlim
- nm
, multibyte
);
1028 #endif /* not DOS_NT */
1034 /* At this point, nm might or might not be an absolute file name. We
1035 need to expand ~ or ~user if present, otherwise prefix nm with
1036 default_directory if nm is not absolute, and finally collapse /./
1037 and /foo/../ sequences.
1039 We set newdir to be the appropriate prefix if one is needed:
1040 - the relevant user directory if nm starts with ~ or ~user
1041 - the specified drive's working dir (DOS/NT only) if nm does not
1043 - the value of default_directory.
1045 Note that these prefixes are not guaranteed to be absolute (except
1046 for the working dir of a drive). Therefore, to ensure we always
1047 return an absolute name, if the final prefix is not absolute we
1048 append it to the current working directory. */
1050 newdir
= newdirlim
= 0;
1052 if (nm
[0] == '~') /* prefix ~ */
1054 if (IS_DIRECTORY_SEP (nm
[1])
1055 || nm
[1] == 0) /* ~ by itself */
1059 if (!(newdir
= egetenv ("HOME")))
1060 newdir
= newdirlim
= "";
1062 /* `egetenv' may return a unibyte string, which will bite us since
1063 we expect the directory to be multibyte. */
1067 char newdir_utf8
[MAX_UTF8_PATH
];
1069 filename_from_ansi (newdir
, newdir_utf8
);
1070 tem
= make_unibyte_string (newdir_utf8
, strlen (newdir_utf8
));
1074 tem
= build_string (newdir
);
1075 newdirlim
= newdir
+ SBYTES (tem
);
1076 if (multibyte
&& !STRING_MULTIBYTE (tem
))
1078 hdir
= DECODE_FILE (tem
);
1079 newdir
= SSDATA (hdir
);
1080 newdirlim
= newdir
+ SBYTES (hdir
);
1083 collapse_newdir
= false;
1086 else /* ~user/filename */
1089 for (p
= nm
; *p
&& !IS_DIRECTORY_SEP (*p
); p
++)
1091 o
= SAFE_ALLOCA (p
- nm
+ 1);
1092 memcpy (o
, nm
, p
- nm
);
1096 pw
= getpwnam (o
+ 1);
1102 newdir
= pw
->pw_dir
;
1103 /* `getpwnam' may return a unibyte string, which will
1104 bite us since we expect the directory to be
1106 tem
= make_unibyte_string (newdir
, strlen (newdir
));
1107 newdirlim
= newdir
+ SBYTES (tem
);
1108 if (multibyte
&& !STRING_MULTIBYTE (tem
))
1110 hdir
= DECODE_FILE (tem
);
1111 newdir
= SSDATA (hdir
);
1112 newdirlim
= newdir
+ SBYTES (hdir
);
1116 collapse_newdir
= false;
1120 /* If we don't find a user of that name, leave the name
1121 unchanged; don't move nm forward to p. */
1126 /* On DOS and Windows, nm is absolute if a drive name was specified;
1127 use the drive's current directory as the prefix if needed. */
1128 if (!newdir
&& drive
)
1130 /* Get default directory if needed to make nm absolute. */
1132 if (!IS_DIRECTORY_SEP (nm
[0]))
1134 adir
= alloca (MAXPATHLEN
+ 1);
1135 if (!getdefdir (c_toupper (drive
) - 'A' + 1, adir
))
1139 Lisp_Object tem
= build_string (adir
);
1141 tem
= DECODE_FILE (tem
);
1142 newdirlim
= adir
+ SBYTES (tem
);
1143 memcpy (adir
, SSDATA (tem
), SBYTES (tem
) + 1);
1146 newdirlim
= adir
+ strlen (adir
);
1150 /* Either nm starts with /, or drive isn't mounted. */
1152 adir
[0] = DRIVE_LETTER (drive
);
1156 newdirlim
= adir
+ 3;
1162 /* Finally, if no prefix has been specified and nm is not absolute,
1163 then it must be expanded relative to default_directory. */
1167 /* /... alone is not absolute on DOS and Windows. */
1168 && !IS_DIRECTORY_SEP (nm
[0])
1171 && !(IS_DIRECTORY_SEP (nm
[0]) && IS_DIRECTORY_SEP (nm
[1])
1172 && !IS_DIRECTORY_SEP (nm
[2]))
1176 newdir
= SSDATA (default_directory
);
1177 newdirlim
= newdir
+ SBYTES (default_directory
);
1179 /* Note if special escape prefix is present, but remove for now. */
1180 if (newdir
[0] == '/' && newdir
[1] == ':')
1191 /* First ensure newdir is an absolute name. */
1193 /* Detect MSDOS file names with drive specifiers. */
1194 ! (IS_DRIVE (newdir
[0])
1195 && IS_DEVICE_SEP (newdir
[1]) && IS_DIRECTORY_SEP (newdir
[2]))
1197 /* Detect Windows file names in UNC format. */
1198 && ! (IS_DIRECTORY_SEP (newdir
[0]) && IS_DIRECTORY_SEP (newdir
[1])
1199 && !IS_DIRECTORY_SEP (newdir
[2]))
1203 /* Effectively, let newdir be (expand-file-name newdir cwd).
1204 Because of the admonition against calling expand-file-name
1205 when we have pointers into lisp strings, we accomplish this
1206 indirectly by prepending newdir to nm if necessary, and using
1207 cwd (or the wd of newdir's drive) as the new newdir. */
1210 const int adir_size
= MAX_UTF8_PATH
;
1212 const int adir_size
= MAXPATHLEN
+ 1;
1215 if (IS_DRIVE (newdir
[0]) && IS_DEVICE_SEP (newdir
[1]))
1217 drive
= (unsigned char) newdir
[0];
1220 if (!IS_DIRECTORY_SEP (nm
[0]))
1222 ptrdiff_t nmlen
= nmlim
- nm
;
1223 ptrdiff_t newdirlen
= newdirlim
- newdir
;
1224 char *tmp
= alloca (newdirlen
+ file_name_as_directory_slop
1226 ptrdiff_t dlen
= file_name_as_directory (tmp
, newdir
, newdirlen
,
1228 memcpy (tmp
+ dlen
, nm
, nmlen
+ 1);
1230 nmlim
= nm
+ dlen
+ nmlen
;
1232 adir
= alloca (adir_size
);
1235 if (!getdefdir (c_toupper (drive
) - 'A' + 1, adir
))
1239 getcwd (adir
, adir_size
);
1242 Lisp_Object tem
= build_string (adir
);
1244 tem
= DECODE_FILE (tem
);
1245 newdirlim
= adir
+ SBYTES (tem
);
1246 memcpy (adir
, SSDATA (tem
), SBYTES (tem
) + 1);
1249 newdirlim
= adir
+ strlen (adir
);
1253 /* Strip off drive name from prefix, if present. */
1254 if (IS_DRIVE (newdir
[0]) && IS_DEVICE_SEP (newdir
[1]))
1260 /* Keep only a prefix from newdir if nm starts with slash
1261 (//server/share for UNC, nothing otherwise). */
1262 if (IS_DIRECTORY_SEP (nm
[0]) && collapse_newdir
)
1265 if (IS_DIRECTORY_SEP (newdir
[0]) && IS_DIRECTORY_SEP (newdir
[1])
1266 && !IS_DIRECTORY_SEP (newdir
[2]))
1268 char *adir
= strcpy (alloca (newdirlim
- newdir
+ 1), newdir
);
1270 while (*p
&& !IS_DIRECTORY_SEP (*p
)) p
++;
1272 while (*p
&& !IS_DIRECTORY_SEP (*p
)) p
++;
1275 newdirlim
= newdir
+ strlen (adir
);
1279 newdir
= newdirlim
= "";
1284 /* Ignore any slash at the end of newdir, unless newdir is
1285 just "/" or "//". */
1286 length
= newdirlim
- newdir
;
1287 while (length
> 1 && IS_DIRECTORY_SEP (newdir
[length
- 1])
1288 && ! (length
== 2 && IS_DIRECTORY_SEP (newdir
[0])))
1291 /* Now concatenate the directory and name to new space in the stack frame. */
1292 tlen
= length
+ file_name_as_directory_slop
+ (nmlim
- nm
) + 1;
1293 eassert (tlen
> file_name_as_directory_slop
+ 1);
1295 /* Reserve space for drive specifier and escape prefix, since either
1296 or both may need to be inserted. (The Microsoft x86 compiler
1297 produces incorrect code if the following two lines are combined.) */
1298 target
= alloca (tlen
+ 4);
1300 #else /* not DOS_NT */
1301 target
= SAFE_ALLOCA (tlen
);
1302 #endif /* not DOS_NT */
1308 if (nm
[0] == 0 || IS_DIRECTORY_SEP (nm
[0]))
1311 /* If newdir is effectively "C:/", then the drive letter will have
1312 been stripped and newdir will be "/". Concatenating with an
1313 absolute directory in nm produces "//", which will then be
1314 incorrectly treated as a network share. Ignore newdir in
1315 this case (keeping the drive letter). */
1316 if (!(drive
&& nm
[0] && IS_DIRECTORY_SEP (newdir
[0])
1317 && newdir
[1] == '\0'))
1320 memcpy (target
, newdir
, length
);
1326 nbytes
= file_name_as_directory (target
, newdir
, length
, multibyte
);
1329 memcpy (target
+ nbytes
, nm
, nmlim
- nm
+ 1);
1331 /* Now canonicalize by removing `//', `/.' and `/foo/..' if they
1339 if (!IS_DIRECTORY_SEP (*p
))
1343 else if (p
[1] == '.'
1344 && (IS_DIRECTORY_SEP (p
[2])
1347 /* If "/." is the entire filename, keep the "/". Otherwise,
1348 just delete the whole "/.". */
1349 if (o
== target
&& p
[2] == '\0')
1353 else if (p
[1] == '.' && p
[2] == '.'
1354 /* `/../' is the "superroot" on certain file systems.
1355 Turned off on DOS_NT systems because they have no
1356 "superroot" and because this causes us to produce
1357 file names like "d:/../foo" which fail file-related
1358 functions of the underlying OS. (To reproduce, try a
1359 long series of "../../" in default_directory, longer
1360 than the number of levels from the root.) */
1364 && (IS_DIRECTORY_SEP (p
[3]) || p
[3] == 0))
1369 while (o
!= target
&& (--o
, !IS_DIRECTORY_SEP (*o
)))
1372 /* Don't go below server level in UNC filenames. */
1373 if (o
== target
+ 1 && IS_DIRECTORY_SEP (*o
)
1374 && IS_DIRECTORY_SEP (*target
))
1378 /* Keep initial / only if this is the whole name. */
1379 if (o
== target
&& IS_ANY_SEP (*o
) && p
[3] == 0)
1383 else if (IS_DIRECTORY_SEP (p
[1])
1384 && (p
!= target
|| IS_DIRECTORY_SEP (p
[2])))
1385 /* Collapse multiple "/", except leave leading "//" alone. */
1394 /* At last, set drive name. */
1396 /* Except for network file name. */
1397 if (!(IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1])))
1398 #endif /* WINDOWSNT */
1400 if (!drive
) emacs_abort ();
1402 target
[0] = DRIVE_LETTER (drive
);
1405 /* Reinsert the escape prefix if required. */
1412 result
= make_specified_string (target
, -1, o
- target
, multibyte
);
1413 dostounix_filename (SSDATA (result
));
1415 if (!NILP (Vw32_downcase_file_names
))
1416 result
= Fdowncase (result
);
1419 result
= make_specified_string (target
, -1, o
- target
, multibyte
);
1420 #endif /* !DOS_NT */
1423 /* Again look to see if the file name has special constructs in it
1424 and perhaps call the corresponding file handler. This is needed
1425 for filenames such as "/foo/../user@host:/bar/../baz". Expanding
1426 the ".." component gives us "/user@host:/bar/../baz" which needs
1427 to be expanded again. */
1428 handler
= Ffind_file_name_handler (result
, Qexpand_file_name
);
1429 if (!NILP (handler
))
1431 handled_name
= call3 (handler
, Qexpand_file_name
,
1432 result
, default_directory
);
1433 if (! STRINGP (handled_name
))
1434 error ("Invalid handler in `file-name-handler-alist'");
1435 result
= handled_name
;
1443 /* PLEASE DO NOT DELETE THIS COMMENTED-OUT VERSION!
1444 This is the old version of expand-file-name, before it was thoroughly
1445 rewritten for Emacs 10.31. We leave this version here commented-out,
1446 because the code is very complex and likely to have subtle bugs. If
1447 bugs _are_ found, it might be of interest to look at the old code and
1448 see what did it do in the relevant situation.
1450 Don't remove this code: it's true that it will be accessible
1451 from the repository, but a few years from deletion, people will
1452 forget it is there. */
1454 /* Changed this DEFUN to a DEAFUN, so as not to confuse `make-docfile'. */
1455 DEAFUN ("expand-file-name", Fexpand_file_name
, Sexpand_file_name
, 1, 2, 0,
1456 "Convert FILENAME to absolute, and canonicalize it.\n\
1457 Second arg DEFAULT is directory to start with if FILENAME is relative\n\
1458 \(does not start with slash); if DEFAULT is nil or missing,\n\
1459 the current buffer's value of default-directory is used.\n\
1460 Filenames containing `.' or `..' as components are simplified;\n\
1461 initial `~/' expands to your home directory.\n\
1462 See also the function `substitute-in-file-name'.")
1464 Lisp_Object name
, defalt
;
1468 register unsigned char *newdir
, *p
, *o
;
1470 unsigned char *target
;
1473 CHECK_STRING (name
);
1476 /* If nm is absolute, flush ...// and detect /./ and /../.
1477 If no /./ or /../ we can return right away. */
1484 if (p
[0] == '/' && p
[1] == '/')
1486 if (p
[0] == '/' && p
[1] == '~')
1487 nm
= p
+ 1, lose
= 1;
1488 if (p
[0] == '/' && p
[1] == '.'
1489 && (p
[2] == '/' || p
[2] == 0
1490 || (p
[2] == '.' && (p
[3] == '/' || p
[3] == 0))))
1496 if (nm
== SDATA (name
))
1498 return build_string (nm
);
1502 /* Now determine directory to start with and put it in NEWDIR. */
1506 if (nm
[0] == '~') /* prefix ~ */
1507 if (nm
[1] == '/' || nm
[1] == 0)/* ~/filename */
1509 if (!(newdir
= (unsigned char *) egetenv ("HOME")))
1510 newdir
= (unsigned char *) "";
1513 else /* ~user/filename */
1515 /* Get past ~ to user. */
1516 unsigned char *user
= nm
+ 1;
1517 /* Find end of name. */
1518 unsigned char *ptr
= (unsigned char *) strchr (user
, '/');
1519 ptrdiff_t len
= ptr
? ptr
- user
: strlen (user
);
1520 /* Copy the user name into temp storage. */
1521 o
= alloca (len
+ 1);
1522 memcpy (o
, user
, len
);
1525 /* Look up the user name. */
1527 pw
= (struct passwd
*) getpwnam (o
+ 1);
1530 error ("\"%s\" isn't a registered user", o
+ 1);
1532 newdir
= (unsigned char *) pw
->pw_dir
;
1534 /* Discard the user name from NM. */
1538 if (nm
[0] != '/' && !newdir
)
1541 defalt
= current_buffer
->directory
;
1542 CHECK_STRING (defalt
);
1543 newdir
= SDATA (defalt
);
1546 /* Now concatenate the directory and name to new space in the stack frame. */
1548 tlen
= (newdir
? strlen (newdir
) + 1 : 0) + strlen (nm
) + 1;
1549 target
= alloca (tlen
);
1554 if (nm
[0] == 0 || nm
[0] == '/')
1555 strcpy (target
, newdir
);
1557 file_name_as_directory (target
, newdir
);
1560 strcat (target
, nm
);
1562 /* Now canonicalize by removing /. and /foo/.. if they appear. */
1573 else if (!strncmp (p
, "//", 2)
1579 else if (p
[0] == '/' && p
[1] == '.'
1580 && (p
[2] == '/' || p
[2] == 0))
1582 else if (!strncmp (p
, "/..", 3)
1583 /* `/../' is the "superroot" on certain file systems. */
1585 && (p
[3] == '/' || p
[3] == 0))
1587 while (o
!= target
&& *--o
!= '/')
1589 if (o
== target
&& *o
== '/')
1599 return make_string (target
, o
- target
);
1603 /* If /~ or // appears, discard everything through first slash. */
1605 file_name_absolute_p (const char *filename
)
1608 (IS_DIRECTORY_SEP (*filename
) || *filename
== '~'
1610 || (IS_DRIVE (*filename
) && IS_DEVICE_SEP (filename
[1])
1611 && IS_DIRECTORY_SEP (filename
[2]))
1617 search_embedded_absfilename (char *nm
, char *endp
)
1621 for (p
= nm
+ 1; p
< endp
; p
++)
1623 if (IS_DIRECTORY_SEP (p
[-1])
1624 && file_name_absolute_p (p
)
1625 #if defined (WINDOWSNT) || defined (CYGWIN)
1626 /* // at start of file name is meaningful in Apollo,
1627 WindowsNT and Cygwin systems. */
1628 && !(IS_DIRECTORY_SEP (p
[0]) && p
- 1 == nm
)
1629 #endif /* not (WINDOWSNT || CYGWIN) */
1632 for (s
= p
; *s
&& !IS_DIRECTORY_SEP (*s
); s
++);
1633 if (p
[0] == '~' && s
> p
+ 1) /* We've got "/~something/". */
1636 char *o
= SAFE_ALLOCA (s
- p
+ 1);
1638 memcpy (o
, p
, s
- p
);
1641 /* If we have ~user and `user' exists, discard
1642 everything up to ~. But if `user' does not exist, leave
1643 ~user alone, it might be a literal file name. */
1645 pw
= getpwnam (o
+ 1);
1658 DEFUN ("substitute-in-file-name", Fsubstitute_in_file_name
,
1659 Ssubstitute_in_file_name
, 1, 1, 0,
1660 doc
: /* Substitute environment variables referred to in FILENAME.
1661 `$FOO' where FOO is an environment variable name means to substitute
1662 the value of that variable. The variable name should be terminated
1663 with a character not a letter, digit or underscore; otherwise, enclose
1664 the entire variable name in braces.
1666 If `/~' appears, all of FILENAME through that `/' is discarded.
1667 If `//' appears, everything up to and including the first of
1668 those `/' is discarded. */)
1669 (Lisp_Object filename
)
1671 char *nm
, *p
, *x
, *endp
;
1672 bool substituted
= false;
1675 Lisp_Object handler
;
1677 CHECK_STRING (filename
);
1679 multibyte
= STRING_MULTIBYTE (filename
);
1681 /* If the file name has special constructs in it,
1682 call the corresponding file handler. */
1683 handler
= Ffind_file_name_handler (filename
, Qsubstitute_in_file_name
);
1684 if (!NILP (handler
))
1686 Lisp_Object handled_name
= call2 (handler
, Qsubstitute_in_file_name
,
1688 if (STRINGP (handled_name
))
1689 return handled_name
;
1690 error ("Invalid handler in `file-name-handler-alist'");
1693 /* Always work on a copy of the string, in case GC happens during
1694 decode of environment variables, causing the original Lisp_String
1695 data to be relocated. */
1697 SAFE_ALLOCA_STRING (nm
, filename
);
1700 dostounix_filename (nm
);
1701 substituted
= (memcmp (nm
, SDATA (filename
), SBYTES (filename
)) != 0);
1703 endp
= nm
+ SBYTES (filename
);
1705 /* If /~ or // appears, discard everything through first slash. */
1706 p
= search_embedded_absfilename (nm
, endp
);
1708 /* Start over with the new string, so we check the file-name-handler
1709 again. Important with filenames like "/home/foo//:/hello///there"
1710 which would substitute to "/:/hello///there" rather than "/there". */
1713 = (Fsubstitute_in_file_name
1714 (make_specified_string (p
, -1, endp
- p
, multibyte
)));
1719 /* See if any variables are substituted into the string. */
1721 if (!NILP (Ffboundp (Qsubstitute_env_in_file_name
)))
1724 = (!substituted
? filename
1725 : make_specified_string (nm
, -1, endp
- nm
, multibyte
));
1726 Lisp_Object tmp
= call1 (Qsubstitute_env_in_file_name
, name
);
1728 if (!EQ (tmp
, name
))
1736 if (!NILP (Vw32_downcase_file_names
))
1737 filename
= Fdowncase (filename
);
1743 xnm
= SSDATA (filename
);
1744 x
= xnm
+ SBYTES (filename
);
1746 /* If /~ or // appears, discard everything through first slash. */
1747 while ((p
= search_embedded_absfilename (xnm
, x
)) != NULL
)
1748 /* This time we do not start over because we've already expanded envvars
1749 and replaced $$ with $. Maybe we should start over as well, but we'd
1750 need to quote some $ to $$ first. */
1754 if (!NILP (Vw32_downcase_file_names
))
1756 Lisp_Object xname
= make_specified_string (xnm
, -1, x
- xnm
, multibyte
);
1758 filename
= Fdowncase (xname
);
1762 if (xnm
!= SSDATA (filename
))
1763 filename
= make_specified_string (xnm
, -1, x
- xnm
, multibyte
);
1768 /* A slightly faster and more convenient way to get
1769 (directory-file-name (expand-file-name FOO)). */
1772 expand_and_dir_to_file (Lisp_Object filename
, Lisp_Object defdir
)
1774 register Lisp_Object absname
;
1776 absname
= Fexpand_file_name (filename
, defdir
);
1778 /* Remove final slash, if any (unless this is the root dir).
1779 stat behaves differently depending! */
1780 if (SCHARS (absname
) > 1
1781 && IS_DIRECTORY_SEP (SREF (absname
, SBYTES (absname
) - 1))
1782 && !IS_DEVICE_SEP (SREF (absname
, SBYTES (absname
) - 2)))
1783 /* We cannot take shortcuts; they might be wrong for magic file names. */
1784 absname
= Fdirectory_file_name (absname
);
1788 /* Signal an error if the file ABSNAME already exists.
1789 If KNOWN_TO_EXIST, the file is known to exist.
1790 QUERYSTRING is a name for the action that is being considered
1792 If INTERACTIVE, ask the user whether to proceed,
1793 and bypass the error if the user says to go ahead.
1794 If QUICK, ask for y or n, not yes or no. */
1797 barf_or_query_if_file_exists (Lisp_Object absname
, bool known_to_exist
,
1798 const char *querystring
, bool interactive
,
1801 Lisp_Object tem
, encoded_filename
;
1802 struct stat statbuf
;
1804 encoded_filename
= ENCODE_FILE (absname
);
1806 if (! known_to_exist
&& lstat (SSDATA (encoded_filename
), &statbuf
) == 0)
1808 if (S_ISDIR (statbuf
.st_mode
))
1809 xsignal2 (Qfile_error
,
1810 build_string ("File is a directory"), absname
);
1811 known_to_exist
= true;
1817 xsignal2 (Qfile_already_exists
,
1818 build_string ("File already exists"), absname
);
1819 AUTO_STRING (format
, "File %s already exists; %s anyway? ");
1820 tem
= CALLN (Fformat
, format
, absname
, build_string (querystring
));
1822 tem
= call1 (intern ("y-or-n-p"), tem
);
1824 tem
= do_yes_or_no_p (tem
);
1826 xsignal2 (Qfile_already_exists
,
1827 build_string ("File already exists"), absname
);
1831 DEFUN ("copy-file", Fcopy_file
, Scopy_file
, 2, 6,
1832 "fCopy file: \nGCopy %s to file: \np\nP",
1833 doc
: /* Copy FILE to NEWNAME. Both args must be strings.
1834 If NEWNAME names a directory, copy FILE there.
1836 This function always sets the file modes of the output file to match
1839 The optional third argument OK-IF-ALREADY-EXISTS specifies what to do
1840 if file NEWNAME already exists. If OK-IF-ALREADY-EXISTS is nil, we
1841 signal a `file-already-exists' error without overwriting. If
1842 OK-IF-ALREADY-EXISTS is a number, we request confirmation from the user
1843 about overwriting; this is what happens in interactive use with M-x.
1844 Any other value for OK-IF-ALREADY-EXISTS means to overwrite the
1847 Fourth arg KEEP-TIME non-nil means give the output file the same
1848 last-modified time as the old one. (This works on only some systems.)
1850 A prefix arg makes KEEP-TIME non-nil.
1852 If PRESERVE-UID-GID is non-nil, we try to transfer the
1853 uid and gid of FILE to NEWNAME.
1855 If PRESERVE-PERMISSIONS is non-nil, copy permissions of FILE to NEWNAME;
1856 this includes the file modes, along with ACL entries and SELinux
1857 context if present. Otherwise, if NEWNAME is created its file
1858 permission bits are those of FILE, masked by the default file
1860 (Lisp_Object file
, Lisp_Object newname
, Lisp_Object ok_if_already_exists
,
1861 Lisp_Object keep_time
, Lisp_Object preserve_uid_gid
,
1862 Lisp_Object preserve_permissions
)
1864 Lisp_Object handler
;
1865 ptrdiff_t count
= SPECPDL_INDEX ();
1866 Lisp_Object encoded_file
, encoded_newname
;
1868 security_context_t con
;
1874 bool already_exists
= false;
1880 encoded_file
= encoded_newname
= Qnil
;
1881 CHECK_STRING (file
);
1882 CHECK_STRING (newname
);
1884 if (!NILP (Ffile_directory_p (newname
)))
1885 newname
= Fexpand_file_name (Ffile_name_nondirectory (file
), newname
);
1887 newname
= Fexpand_file_name (newname
, Qnil
);
1889 file
= Fexpand_file_name (file
, Qnil
);
1891 /* If the input file name has special constructs in it,
1892 call the corresponding file handler. */
1893 handler
= Ffind_file_name_handler (file
, Qcopy_file
);
1894 /* Likewise for output file name. */
1896 handler
= Ffind_file_name_handler (newname
, Qcopy_file
);
1897 if (!NILP (handler
))
1898 return call7 (handler
, Qcopy_file
, file
, newname
,
1899 ok_if_already_exists
, keep_time
, preserve_uid_gid
,
1900 preserve_permissions
);
1902 encoded_file
= ENCODE_FILE (file
);
1903 encoded_newname
= ENCODE_FILE (newname
);
1906 if (NILP (ok_if_already_exists
)
1907 || INTEGERP (ok_if_already_exists
))
1908 barf_or_query_if_file_exists (newname
, false, "copy to it",
1909 INTEGERP (ok_if_already_exists
), false);
1911 result
= w32_copy_file (SSDATA (encoded_file
), SSDATA (encoded_newname
),
1912 !NILP (keep_time
), !NILP (preserve_uid_gid
),
1913 !NILP (preserve_permissions
));
1917 report_file_error ("Copying file", list2 (file
, newname
));
1919 report_file_error ("Copying permissions from", file
);
1921 xsignal2 (Qfile_date_error
,
1922 build_string ("Resetting file times"), newname
);
1924 report_file_error ("Copying permissions to", newname
);
1926 #else /* not WINDOWSNT */
1928 ifd
= emacs_open (SSDATA (encoded_file
), O_RDONLY
, 0);
1932 report_file_error ("Opening input file", file
);
1934 record_unwind_protect_int (close_file_unwind
, ifd
);
1936 if (fstat (ifd
, &st
) != 0)
1937 report_file_error ("Input file status", file
);
1939 if (!NILP (preserve_permissions
))
1942 if (is_selinux_enabled ())
1944 conlength
= fgetfilecon (ifd
, &con
);
1945 if (conlength
== -1)
1946 report_file_error ("Doing fgetfilecon", file
);
1951 /* We can copy only regular files. */
1952 if (!S_ISREG (st
.st_mode
))
1953 report_file_errno ("Non-regular file", file
,
1954 S_ISDIR (st
.st_mode
) ? EISDIR
: EINVAL
);
1957 new_mask
= st
.st_mode
& (!NILP (preserve_uid_gid
) ? 0700 : 0777);
1959 new_mask
= S_IREAD
| S_IWRITE
;
1962 ofd
= emacs_open (SSDATA (encoded_newname
), O_WRONLY
| O_CREAT
| O_EXCL
,
1964 if (ofd
< 0 && errno
== EEXIST
)
1966 if (NILP (ok_if_already_exists
) || INTEGERP (ok_if_already_exists
))
1967 barf_or_query_if_file_exists (newname
, true, "copy to it",
1968 INTEGERP (ok_if_already_exists
), false);
1969 already_exists
= true;
1970 ofd
= emacs_open (SSDATA (encoded_newname
), O_WRONLY
, 0);
1973 report_file_error ("Opening output file", newname
);
1975 record_unwind_protect_int (close_file_unwind
, ofd
);
1977 off_t oldsize
= 0, newsize
= 0;
1982 if (fstat (ofd
, &out_st
) != 0)
1983 report_file_error ("Output file status", newname
);
1984 if (st
.st_dev
== out_st
.st_dev
&& st
.st_ino
== out_st
.st_ino
)
1985 report_file_errno ("Input and output files are the same",
1986 list2 (file
, newname
), 0);
1987 if (S_ISREG (out_st
.st_mode
))
1988 oldsize
= out_st
.st_size
;
1995 char buf
[MAX_ALLOCA
];
1996 ptrdiff_t n
= emacs_read (ifd
, buf
, sizeof buf
);
1998 report_file_error ("Read error", file
);
2001 if (emacs_write_sig (ofd
, buf
, n
) != n
)
2002 report_file_error ("Write error", newname
);
2006 /* Truncate any existing output file after writing the data. This
2007 is more likely to work than truncation before writing, if the
2008 file system is out of space or the user is over disk quota. */
2009 if (newsize
< oldsize
&& ftruncate (ofd
, newsize
) != 0)
2010 report_file_error ("Truncating output file", newname
);
2015 /* Preserve the original file permissions, and if requested, also its
2018 mode_t preserved_permissions
= st
.st_mode
& 07777;
2019 mode_t default_permissions
= st
.st_mode
& 0777 & ~realmask
;
2020 if (!NILP (preserve_uid_gid
))
2022 /* Attempt to change owner and group. If that doesn't work
2023 attempt to change just the group, as that is sometimes allowed.
2024 Adjust the mode mask to eliminate setuid or setgid bits
2025 or group permissions bits that are inappropriate if the
2026 owner or group are wrong. */
2027 if (fchown (ofd
, st
.st_uid
, st
.st_gid
) != 0)
2029 if (fchown (ofd
, -1, st
.st_gid
) == 0)
2030 preserved_permissions
&= ~04000;
2033 preserved_permissions
&= ~06000;
2035 /* Copy the other bits to the group bits, since the
2037 preserved_permissions
&= ~070;
2038 preserved_permissions
|= (preserved_permissions
& 7) << 3;
2039 default_permissions
&= ~070;
2040 default_permissions
|= (default_permissions
& 7) << 3;
2045 switch (!NILP (preserve_permissions
)
2046 ? qcopy_acl (SSDATA (encoded_file
), ifd
,
2047 SSDATA (encoded_newname
), ofd
,
2048 preserved_permissions
)
2050 || (new_mask
& ~realmask
) == default_permissions
)
2052 : fchmod (ofd
, default_permissions
))
2054 case -2: report_file_error ("Copying permissions from", file
);
2055 case -1: report_file_error ("Copying permissions to", newname
);
2058 #endif /* not MSDOS */
2063 /* Set the modified context back to the file. */
2064 bool fail
= fsetfilecon (ofd
, con
) != 0;
2065 /* See http://debbugs.gnu.org/11245 for ENOTSUP. */
2066 if (fail
&& errno
!= ENOTSUP
)
2067 report_file_error ("Doing fsetfilecon", newname
);
2073 if (!NILP (keep_time
))
2075 struct timespec atime
= get_stat_atime (&st
);
2076 struct timespec mtime
= get_stat_mtime (&st
);
2077 if (set_file_times (ofd
, SSDATA (encoded_newname
), atime
, mtime
) != 0)
2078 xsignal2 (Qfile_date_error
,
2079 build_string ("Cannot set file date"), newname
);
2082 if (emacs_close (ofd
) < 0)
2083 report_file_error ("Write error", newname
);
2088 /* In DJGPP v2.0 and later, fstat usually returns true file mode bits,
2089 and if it can't, it tells so. Otherwise, under MSDOS we usually
2090 get only the READ bit, which will make the copied file read-only,
2091 so it's better not to chmod at all. */
2092 if ((_djstat_flags
& _STFAIL_WRITEBIT
) == 0)
2093 chmod (SDATA (encoded_newname
), st
.st_mode
& 07777);
2095 #endif /* not WINDOWSNT */
2097 /* Discard the unwind protects. */
2098 specpdl_ptr
= specpdl
+ count
;
2103 DEFUN ("make-directory-internal", Fmake_directory_internal
,
2104 Smake_directory_internal
, 1, 1, 0,
2105 doc
: /* Create a new directory named DIRECTORY. */)
2106 (Lisp_Object directory
)
2109 Lisp_Object handler
;
2110 Lisp_Object encoded_dir
;
2112 CHECK_STRING (directory
);
2113 directory
= Fexpand_file_name (directory
, Qnil
);
2115 handler
= Ffind_file_name_handler (directory
, Qmake_directory_internal
);
2116 if (!NILP (handler
))
2117 return call2 (handler
, Qmake_directory_internal
, directory
);
2119 encoded_dir
= ENCODE_FILE (directory
);
2121 dir
= SSDATA (encoded_dir
);
2124 if (mkdir (dir
) != 0)
2126 if (mkdir (dir
, 0777 & ~auto_saving_dir_umask
) != 0)
2128 report_file_error ("Creating directory", directory
);
2133 DEFUN ("delete-directory-internal", Fdelete_directory_internal
,
2134 Sdelete_directory_internal
, 1, 1, 0,
2135 doc
: /* Delete the directory named DIRECTORY. Does not follow symlinks. */)
2136 (Lisp_Object directory
)
2139 Lisp_Object encoded_dir
;
2141 CHECK_STRING (directory
);
2142 directory
= Fdirectory_file_name (Fexpand_file_name (directory
, Qnil
));
2143 encoded_dir
= ENCODE_FILE (directory
);
2144 dir
= SSDATA (encoded_dir
);
2146 if (rmdir (dir
) != 0)
2147 report_file_error ("Removing directory", directory
);
2152 DEFUN ("delete-file", Fdelete_file
, Sdelete_file
, 1, 2,
2153 "(list (read-file-name \
2154 (if (and delete-by-moving-to-trash (null current-prefix-arg)) \
2155 \"Move file to trash: \" \"Delete file: \") \
2156 nil default-directory (confirm-nonexistent-file-or-buffer)) \
2157 (null current-prefix-arg))",
2158 doc
: /* Delete file named FILENAME. If it is a symlink, remove the symlink.
2159 If file has multiple names, it continues to exist with the other names.
2160 TRASH non-nil means to trash the file instead of deleting, provided
2161 `delete-by-moving-to-trash' is non-nil.
2163 When called interactively, TRASH is t if no prefix argument is given.
2164 With a prefix argument, TRASH is nil. */)
2165 (Lisp_Object filename
, Lisp_Object trash
)
2167 Lisp_Object handler
;
2168 Lisp_Object encoded_file
;
2170 if (!NILP (Ffile_directory_p (filename
))
2171 && NILP (Ffile_symlink_p (filename
)))
2172 xsignal2 (Qfile_error
,
2173 build_string ("Removing old name: is a directory"),
2175 filename
= Fexpand_file_name (filename
, Qnil
);
2177 handler
= Ffind_file_name_handler (filename
, Qdelete_file
);
2178 if (!NILP (handler
))
2179 return call3 (handler
, Qdelete_file
, filename
, trash
);
2181 if (delete_by_moving_to_trash
&& !NILP (trash
))
2182 return call1 (Qmove_file_to_trash
, filename
);
2184 encoded_file
= ENCODE_FILE (filename
);
2186 if (unlink (SSDATA (encoded_file
)) < 0)
2187 report_file_error ("Removing old name", filename
);
2192 internal_delete_file_1 (Lisp_Object ignore
)
2197 /* Delete file FILENAME, returning true if successful.
2198 This ignores `delete-by-moving-to-trash'. */
2201 internal_delete_file (Lisp_Object filename
)
2205 tem
= internal_condition_case_2 (Fdelete_file
, filename
, Qnil
,
2206 Qt
, internal_delete_file_1
);
2210 DEFUN ("rename-file", Frename_file
, Srename_file
, 2, 3,
2211 "fRename file: \nGRename %s to file: \np",
2212 doc
: /* Rename FILE as NEWNAME. Both args must be strings.
2213 If file has names other than FILE, it continues to have those names.
2214 Signals a `file-already-exists' error if a file NEWNAME already exists
2215 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
2216 A number as third arg means request confirmation if NEWNAME already exists.
2217 This is what happens in interactive use with M-x. */)
2218 (Lisp_Object file
, Lisp_Object newname
, Lisp_Object ok_if_already_exists
)
2220 Lisp_Object handler
;
2221 Lisp_Object encoded_file
, encoded_newname
, symlink_target
;
2223 symlink_target
= encoded_file
= encoded_newname
= Qnil
;
2224 CHECK_STRING (file
);
2225 CHECK_STRING (newname
);
2226 file
= Fexpand_file_name (file
, Qnil
);
2228 if ((!NILP (Ffile_directory_p (newname
)))
2230 /* If the file names are identical but for the case,
2231 don't attempt to move directory to itself. */
2232 && (NILP (Fstring_equal (Fdowncase (file
), Fdowncase (newname
))))
2236 Lisp_Object fname
= (NILP (Ffile_directory_p (file
))
2237 ? file
: Fdirectory_file_name (file
));
2238 newname
= Fexpand_file_name (Ffile_name_nondirectory (fname
), newname
);
2241 newname
= Fexpand_file_name (newname
, Qnil
);
2243 /* If the file name has special constructs in it,
2244 call the corresponding file handler. */
2245 handler
= Ffind_file_name_handler (file
, Qrename_file
);
2247 handler
= Ffind_file_name_handler (newname
, Qrename_file
);
2248 if (!NILP (handler
))
2249 return call4 (handler
, Qrename_file
,
2250 file
, newname
, ok_if_already_exists
);
2252 encoded_file
= ENCODE_FILE (file
);
2253 encoded_newname
= ENCODE_FILE (newname
);
2256 /* If the file names are identical but for the case, don't ask for
2257 confirmation: they simply want to change the letter-case of the
2259 if (NILP (Fstring_equal (Fdowncase (file
), Fdowncase (newname
))))
2261 if (NILP (ok_if_already_exists
)
2262 || INTEGERP (ok_if_already_exists
))
2263 barf_or_query_if_file_exists (newname
, false, "rename to it",
2264 INTEGERP (ok_if_already_exists
), false);
2265 if (rename (SSDATA (encoded_file
), SSDATA (encoded_newname
)) < 0)
2267 int rename_errno
= errno
;
2268 if (rename_errno
== EXDEV
)
2271 symlink_target
= Ffile_symlink_p (file
);
2272 if (! NILP (symlink_target
))
2273 Fmake_symbolic_link (symlink_target
, newname
,
2274 NILP (ok_if_already_exists
) ? Qnil
: Qt
);
2275 else if (!NILP (Ffile_directory_p (file
)))
2276 call4 (Qcopy_directory
, file
, newname
, Qt
, Qnil
);
2278 /* We have already prompted if it was an integer, so don't
2279 have copy-file prompt again. */
2280 Fcopy_file (file
, newname
,
2281 NILP (ok_if_already_exists
) ? Qnil
: Qt
,
2284 count
= SPECPDL_INDEX ();
2285 specbind (Qdelete_by_moving_to_trash
, Qnil
);
2287 if (!NILP (Ffile_directory_p (file
)) && NILP (symlink_target
))
2288 call2 (Qdelete_directory
, file
, Qt
);
2290 Fdelete_file (file
, Qnil
);
2291 unbind_to (count
, Qnil
);
2294 report_file_errno ("Renaming", list2 (file
, newname
), rename_errno
);
2300 DEFUN ("add-name-to-file", Fadd_name_to_file
, Sadd_name_to_file
, 2, 3,
2301 "fAdd name to file: \nGName to add to %s: \np",
2302 doc
: /* Give FILE additional name NEWNAME. Both args must be strings.
2303 Signals a `file-already-exists' error if a file NEWNAME already exists
2304 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
2305 A number as third arg means request confirmation if NEWNAME already exists.
2306 This is what happens in interactive use with M-x. */)
2307 (Lisp_Object file
, Lisp_Object newname
, Lisp_Object ok_if_already_exists
)
2309 Lisp_Object handler
;
2310 Lisp_Object encoded_file
, encoded_newname
;
2312 encoded_file
= encoded_newname
= Qnil
;
2313 CHECK_STRING (file
);
2314 CHECK_STRING (newname
);
2315 file
= Fexpand_file_name (file
, Qnil
);
2317 if (!NILP (Ffile_directory_p (newname
)))
2318 newname
= Fexpand_file_name (Ffile_name_nondirectory (file
), newname
);
2320 newname
= Fexpand_file_name (newname
, Qnil
);
2322 /* If the file name has special constructs in it,
2323 call the corresponding file handler. */
2324 handler
= Ffind_file_name_handler (file
, Qadd_name_to_file
);
2325 if (!NILP (handler
))
2326 return call4 (handler
, Qadd_name_to_file
, file
,
2327 newname
, ok_if_already_exists
);
2329 /* If the new name has special constructs in it,
2330 call the corresponding file handler. */
2331 handler
= Ffind_file_name_handler (newname
, Qadd_name_to_file
);
2332 if (!NILP (handler
))
2333 return call4 (handler
, Qadd_name_to_file
, file
,
2334 newname
, ok_if_already_exists
);
2336 encoded_file
= ENCODE_FILE (file
);
2337 encoded_newname
= ENCODE_FILE (newname
);
2339 if (NILP (ok_if_already_exists
)
2340 || INTEGERP (ok_if_already_exists
))
2341 barf_or_query_if_file_exists (newname
, false, "make it a new name",
2342 INTEGERP (ok_if_already_exists
), false);
2344 unlink (SSDATA (newname
));
2345 if (link (SSDATA (encoded_file
), SSDATA (encoded_newname
)) < 0)
2347 int link_errno
= errno
;
2348 report_file_errno ("Adding new name", list2 (file
, newname
), link_errno
);
2354 DEFUN ("make-symbolic-link", Fmake_symbolic_link
, Smake_symbolic_link
, 2, 3,
2355 "FMake symbolic link to file: \nGMake symbolic link to file %s: \np",
2356 doc
: /* Make a symbolic link to TARGET, named LINKNAME.
2357 Both args must be strings.
2358 Signals a `file-already-exists' error if a file LINKNAME already exists
2359 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
2360 A number as third arg means request confirmation if LINKNAME already exists.
2361 This happens for interactive use with M-x. */)
2362 (Lisp_Object target
, Lisp_Object linkname
, Lisp_Object ok_if_already_exists
)
2364 Lisp_Object handler
;
2365 Lisp_Object encoded_target
, encoded_linkname
;
2367 encoded_target
= encoded_linkname
= Qnil
;
2368 CHECK_STRING (target
);
2369 CHECK_STRING (linkname
);
2370 /* If the link target has a ~, we must expand it to get
2371 a truly valid file name. Otherwise, do not expand;
2372 we want to permit links to relative file names. */
2373 if (SREF (target
, 0) == '~')
2374 target
= Fexpand_file_name (target
, Qnil
);
2376 if (!NILP (Ffile_directory_p (linkname
)))
2377 linkname
= Fexpand_file_name (Ffile_name_nondirectory (target
), linkname
);
2379 linkname
= Fexpand_file_name (linkname
, Qnil
);
2381 /* If the file name has special constructs in it,
2382 call the corresponding file handler. */
2383 handler
= Ffind_file_name_handler (target
, Qmake_symbolic_link
);
2384 if (!NILP (handler
))
2385 return call4 (handler
, Qmake_symbolic_link
, target
,
2386 linkname
, ok_if_already_exists
);
2388 /* If the new link name has special constructs in it,
2389 call the corresponding file handler. */
2390 handler
= Ffind_file_name_handler (linkname
, Qmake_symbolic_link
);
2391 if (!NILP (handler
))
2392 return call4 (handler
, Qmake_symbolic_link
, target
,
2393 linkname
, ok_if_already_exists
);
2395 encoded_target
= ENCODE_FILE (target
);
2396 encoded_linkname
= ENCODE_FILE (linkname
);
2398 if (NILP (ok_if_already_exists
)
2399 || INTEGERP (ok_if_already_exists
))
2400 barf_or_query_if_file_exists (linkname
, false, "make it a link",
2401 INTEGERP (ok_if_already_exists
), false);
2402 if (symlink (SSDATA (encoded_target
), SSDATA (encoded_linkname
)) < 0)
2404 /* If we didn't complain already, silently delete existing file. */
2406 if (errno
== EEXIST
)
2408 unlink (SSDATA (encoded_linkname
));
2409 if (symlink (SSDATA (encoded_target
), SSDATA (encoded_linkname
))
2413 if (errno
== ENOSYS
)
2414 xsignal1 (Qfile_error
,
2415 build_string ("Symbolic links are not supported"));
2417 symlink_errno
= errno
;
2418 report_file_errno ("Making symbolic link", list2 (target
, linkname
),
2426 DEFUN ("file-name-absolute-p", Ffile_name_absolute_p
, Sfile_name_absolute_p
,
2428 doc
: /* Return t if file FILENAME specifies an absolute file name.
2429 On Unix, this is a name starting with a `/' or a `~'. */)
2430 (Lisp_Object filename
)
2432 CHECK_STRING (filename
);
2433 return file_name_absolute_p (SSDATA (filename
)) ? Qt
: Qnil
;
2436 DEFUN ("file-exists-p", Ffile_exists_p
, Sfile_exists_p
, 1, 1, 0,
2437 doc
: /* Return t if file FILENAME exists (whether or not you can read it.)
2438 See also `file-readable-p' and `file-attributes'.
2439 This returns nil for a symlink to a nonexistent file.
2440 Use `file-symlink-p' to test for such links. */)
2441 (Lisp_Object filename
)
2443 Lisp_Object absname
;
2444 Lisp_Object handler
;
2446 CHECK_STRING (filename
);
2447 absname
= Fexpand_file_name (filename
, Qnil
);
2449 /* If the file name has special constructs in it,
2450 call the corresponding file handler. */
2451 handler
= Ffind_file_name_handler (absname
, Qfile_exists_p
);
2452 if (!NILP (handler
))
2454 Lisp_Object result
= call2 (handler
, Qfile_exists_p
, absname
);
2459 absname
= ENCODE_FILE (absname
);
2461 return check_existing (SSDATA (absname
)) ? Qt
: Qnil
;
2464 DEFUN ("file-executable-p", Ffile_executable_p
, Sfile_executable_p
, 1, 1, 0,
2465 doc
: /* Return t if FILENAME can be executed by you.
2466 For a directory, this means you can access files in that directory.
2467 \(It is generally better to use `file-accessible-directory-p' for that
2468 purpose, though.) */)
2469 (Lisp_Object filename
)
2471 Lisp_Object absname
;
2472 Lisp_Object handler
;
2474 CHECK_STRING (filename
);
2475 absname
= Fexpand_file_name (filename
, Qnil
);
2477 /* If the file name has special constructs in it,
2478 call the corresponding file handler. */
2479 handler
= Ffind_file_name_handler (absname
, Qfile_executable_p
);
2480 if (!NILP (handler
))
2481 return call2 (handler
, Qfile_executable_p
, absname
);
2483 absname
= ENCODE_FILE (absname
);
2485 return (check_executable (SSDATA (absname
)) ? Qt
: Qnil
);
2488 DEFUN ("file-readable-p", Ffile_readable_p
, Sfile_readable_p
, 1, 1, 0,
2489 doc
: /* Return t if file FILENAME exists and you can read it.
2490 See also `file-exists-p' and `file-attributes'. */)
2491 (Lisp_Object filename
)
2493 Lisp_Object absname
;
2494 Lisp_Object handler
;
2496 CHECK_STRING (filename
);
2497 absname
= Fexpand_file_name (filename
, Qnil
);
2499 /* If the file name has special constructs in it,
2500 call the corresponding file handler. */
2501 handler
= Ffind_file_name_handler (absname
, Qfile_readable_p
);
2502 if (!NILP (handler
))
2503 return call2 (handler
, Qfile_readable_p
, absname
);
2505 absname
= ENCODE_FILE (absname
);
2506 return (faccessat (AT_FDCWD
, SSDATA (absname
), R_OK
, AT_EACCESS
) == 0
2510 DEFUN ("file-writable-p", Ffile_writable_p
, Sfile_writable_p
, 1, 1, 0,
2511 doc
: /* Return t if file FILENAME can be written or created by you. */)
2512 (Lisp_Object filename
)
2514 Lisp_Object absname
, dir
, encoded
;
2515 Lisp_Object handler
;
2517 CHECK_STRING (filename
);
2518 absname
= Fexpand_file_name (filename
, Qnil
);
2520 /* If the file name has special constructs in it,
2521 call the corresponding file handler. */
2522 handler
= Ffind_file_name_handler (absname
, Qfile_writable_p
);
2523 if (!NILP (handler
))
2524 return call2 (handler
, Qfile_writable_p
, absname
);
2526 encoded
= ENCODE_FILE (absname
);
2527 if (check_writable (SSDATA (encoded
), W_OK
))
2529 if (errno
!= ENOENT
)
2532 dir
= Ffile_name_directory (absname
);
2533 eassert (!NILP (dir
));
2535 dir
= Fdirectory_file_name (dir
);
2538 dir
= ENCODE_FILE (dir
);
2540 /* The read-only attribute of the parent directory doesn't affect
2541 whether a file or directory can be created within it. Some day we
2542 should check ACLs though, which do affect this. */
2543 return file_directory_p (SSDATA (dir
)) ? Qt
: Qnil
;
2545 return check_writable (SSDATA (dir
), W_OK
| X_OK
) ? Qt
: Qnil
;
2549 DEFUN ("access-file", Faccess_file
, Saccess_file
, 2, 2, 0,
2550 doc
: /* Access file FILENAME, and get an error if that does not work.
2551 The second argument STRING is used in the error message.
2552 If there is no error, returns nil. */)
2553 (Lisp_Object filename
, Lisp_Object string
)
2555 Lisp_Object handler
, encoded_filename
, absname
;
2557 CHECK_STRING (filename
);
2558 absname
= Fexpand_file_name (filename
, Qnil
);
2560 CHECK_STRING (string
);
2562 /* If the file name has special constructs in it,
2563 call the corresponding file handler. */
2564 handler
= Ffind_file_name_handler (absname
, Qaccess_file
);
2565 if (!NILP (handler
))
2566 return call3 (handler
, Qaccess_file
, absname
, string
);
2568 encoded_filename
= ENCODE_FILE (absname
);
2570 if (faccessat (AT_FDCWD
, SSDATA (encoded_filename
), R_OK
, AT_EACCESS
) != 0)
2571 report_file_error (SSDATA (string
), filename
);
2576 /* Relative to directory FD, return the symbolic link value of FILENAME.
2577 On failure, return nil. */
2579 emacs_readlinkat (int fd
, char const *filename
)
2581 static struct allocator
const emacs_norealloc_allocator
=
2582 { xmalloc
, NULL
, xfree
, memory_full
};
2584 char readlink_buf
[1024];
2585 char *buf
= careadlinkat (fd
, filename
, readlink_buf
, sizeof readlink_buf
,
2586 &emacs_norealloc_allocator
, readlinkat
);
2590 val
= build_unibyte_string (buf
);
2591 if (buf
[0] == '/' && strchr (buf
, ':'))
2593 AUTO_STRING (slash_colon
, "/:");
2594 val
= concat2 (slash_colon
, val
);
2596 if (buf
!= readlink_buf
)
2598 val
= DECODE_FILE (val
);
2602 DEFUN ("file-symlink-p", Ffile_symlink_p
, Sfile_symlink_p
, 1, 1, 0,
2603 doc
: /* Return non-nil if file FILENAME is the name of a symbolic link.
2604 The value is the link target, as a string.
2605 Otherwise it returns nil.
2607 This function does not check whether the link target exists. */)
2608 (Lisp_Object filename
)
2610 Lisp_Object handler
;
2612 CHECK_STRING (filename
);
2613 filename
= Fexpand_file_name (filename
, Qnil
);
2615 /* If the file name has special constructs in it,
2616 call the corresponding file handler. */
2617 handler
= Ffind_file_name_handler (filename
, Qfile_symlink_p
);
2618 if (!NILP (handler
))
2619 return call2 (handler
, Qfile_symlink_p
, filename
);
2621 filename
= ENCODE_FILE (filename
);
2623 return emacs_readlinkat (AT_FDCWD
, SSDATA (filename
));
2626 DEFUN ("file-directory-p", Ffile_directory_p
, Sfile_directory_p
, 1, 1, 0,
2627 doc
: /* Return t if FILENAME names an existing directory.
2628 Symbolic links to directories count as directories.
2629 See `file-symlink-p' to distinguish symlinks. */)
2630 (Lisp_Object filename
)
2632 Lisp_Object absname
;
2633 Lisp_Object handler
;
2635 absname
= expand_and_dir_to_file (filename
, BVAR (current_buffer
, directory
));
2637 /* If the file name has special constructs in it,
2638 call the corresponding file handler. */
2639 handler
= Ffind_file_name_handler (absname
, Qfile_directory_p
);
2640 if (!NILP (handler
))
2641 return call2 (handler
, Qfile_directory_p
, absname
);
2643 absname
= ENCODE_FILE (absname
);
2645 return file_directory_p (SSDATA (absname
)) ? Qt
: Qnil
;
2648 /* Return true if FILE is a directory or a symlink to a directory. */
2650 file_directory_p (char const *file
)
2653 /* This is cheaper than 'stat'. */
2654 return faccessat (AT_FDCWD
, file
, D_OK
, AT_EACCESS
) == 0;
2657 return stat (file
, &st
) == 0 && S_ISDIR (st
.st_mode
);
2661 DEFUN ("file-accessible-directory-p", Ffile_accessible_directory_p
,
2662 Sfile_accessible_directory_p
, 1, 1, 0,
2663 doc
: /* Return t if FILENAME names a directory you can open.
2664 For the value to be t, FILENAME must specify the name of a directory
2665 as a file, and the directory must allow you to open files in it. In
2666 order to use a directory as a buffer's current directory, this
2667 predicate must return true. A directory name spec may be given
2668 instead; then the value is t if the directory so specified exists and
2669 really is a readable and searchable directory. */)
2670 (Lisp_Object filename
)
2672 Lisp_Object absname
;
2673 Lisp_Object handler
;
2675 CHECK_STRING (filename
);
2676 absname
= Fexpand_file_name (filename
, Qnil
);
2678 /* If the file name has special constructs in it,
2679 call the corresponding file handler. */
2680 handler
= Ffind_file_name_handler (absname
, Qfile_accessible_directory_p
);
2681 if (!NILP (handler
))
2683 Lisp_Object r
= call2 (handler
, Qfile_accessible_directory_p
, absname
);
2688 absname
= ENCODE_FILE (absname
);
2689 return file_accessible_directory_p (absname
) ? Qt
: Qnil
;
2692 /* If FILE is a searchable directory or a symlink to a
2693 searchable directory, return true. Otherwise return
2694 false and set errno to an error number. */
2696 file_accessible_directory_p (Lisp_Object file
)
2700 /* We need a special-purpose test because (a) NTFS security data is
2701 not reflected in Posix-style mode bits, and (b) the trick with
2702 accessing "DIR/.", used below on Posix hosts, doesn't work on
2703 Windows, because "DIR/." is normalized to just "DIR" before
2704 hitting the disk. */
2705 return (SBYTES (file
) == 0
2706 || w32_accessible_directory_p (SSDATA (file
), SBYTES (file
)));
2708 return file_directory_p (SSDATA (file
));
2711 /* On POSIXish platforms, use just one system call; this avoids a
2712 race and is typically faster. */
2713 const char *data
= SSDATA (file
);
2714 ptrdiff_t len
= SBYTES (file
);
2720 /* Normally a file "FOO" is an accessible directory if "FOO/." exists.
2721 There are three exceptions: "", "/", and "//". Leave "" alone,
2722 as it's invalid. Append only "." to the other two exceptions as
2723 "/" and "//" are distinct on some platforms, whereas "/", "///",
2724 "////", etc. are all equivalent. */
2729 /* Just check for trailing '/' when deciding whether to append '/'.
2730 That's simpler than testing the two special cases "/" and "//",
2731 and it's a safe optimization here. */
2732 char *buf
= SAFE_ALLOCA (len
+ 3);
2733 memcpy (buf
, data
, len
);
2734 strcpy (buf
+ len
, &"/."[data
[len
- 1] == '/']);
2738 ok
= check_existing (dir
);
2739 saved_errno
= errno
;
2741 errno
= saved_errno
;
2743 #endif /* !DOS_NT */
2746 DEFUN ("file-regular-p", Ffile_regular_p
, Sfile_regular_p
, 1, 1, 0,
2747 doc
: /* Return t if FILENAME names a regular file.
2748 This is the sort of file that holds an ordinary stream of data bytes.
2749 Symbolic links to regular files count as regular files.
2750 See `file-symlink-p' to distinguish symlinks. */)
2751 (Lisp_Object filename
)
2753 register Lisp_Object absname
;
2755 Lisp_Object handler
;
2757 absname
= expand_and_dir_to_file (filename
, BVAR (current_buffer
, directory
));
2759 /* If the file name has special constructs in it,
2760 call the corresponding file handler. */
2761 handler
= Ffind_file_name_handler (absname
, Qfile_regular_p
);
2762 if (!NILP (handler
))
2763 return call2 (handler
, Qfile_regular_p
, absname
);
2765 absname
= ENCODE_FILE (absname
);
2770 Lisp_Object tem
= Vw32_get_true_file_attributes
;
2772 /* Tell stat to use expensive method to get accurate info. */
2773 Vw32_get_true_file_attributes
= Qt
;
2774 result
= stat (SSDATA (absname
), &st
);
2775 Vw32_get_true_file_attributes
= tem
;
2779 return S_ISREG (st
.st_mode
) ? Qt
: Qnil
;
2782 if (stat (SSDATA (absname
), &st
) < 0)
2784 return S_ISREG (st
.st_mode
) ? Qt
: Qnil
;
2788 DEFUN ("file-selinux-context", Ffile_selinux_context
,
2789 Sfile_selinux_context
, 1, 1, 0,
2790 doc
: /* Return SELinux context of file named FILENAME.
2791 The return value is a list (USER ROLE TYPE RANGE), where the list
2792 elements are strings naming the user, role, type, and range of the
2793 file's SELinux security context.
2795 Return (nil nil nil nil) if the file is nonexistent or inaccessible,
2796 or if SELinux is disabled, or if Emacs lacks SELinux support. */)
2797 (Lisp_Object filename
)
2799 Lisp_Object absname
;
2800 Lisp_Object user
= Qnil
, role
= Qnil
, type
= Qnil
, range
= Qnil
;
2802 Lisp_Object handler
;
2804 security_context_t con
;
2809 absname
= expand_and_dir_to_file (filename
, BVAR (current_buffer
, directory
));
2811 /* If the file name has special constructs in it,
2812 call the corresponding file handler. */
2813 handler
= Ffind_file_name_handler (absname
, Qfile_selinux_context
);
2814 if (!NILP (handler
))
2815 return call2 (handler
, Qfile_selinux_context
, absname
);
2817 absname
= ENCODE_FILE (absname
);
2820 if (is_selinux_enabled ())
2822 conlength
= lgetfilecon (SSDATA (absname
), &con
);
2825 context
= context_new (con
);
2826 if (context_user_get (context
))
2827 user
= build_string (context_user_get (context
));
2828 if (context_role_get (context
))
2829 role
= build_string (context_role_get (context
));
2830 if (context_type_get (context
))
2831 type
= build_string (context_type_get (context
));
2832 if (context_range_get (context
))
2833 range
= build_string (context_range_get (context
));
2834 context_free (context
);
2840 return list4 (user
, role
, type
, range
);
2843 DEFUN ("set-file-selinux-context", Fset_file_selinux_context
,
2844 Sset_file_selinux_context
, 2, 2, 0,
2845 doc
: /* Set SELinux context of file named FILENAME to CONTEXT.
2846 CONTEXT should be a list (USER ROLE TYPE RANGE), where the list
2847 elements are strings naming the components of a SELinux context.
2849 Value is t if setting of SELinux context was successful, nil otherwise.
2851 This function does nothing and returns nil if SELinux is disabled,
2852 or if Emacs was not compiled with SELinux support. */)
2853 (Lisp_Object filename
, Lisp_Object context
)
2855 Lisp_Object absname
;
2856 Lisp_Object handler
;
2858 Lisp_Object encoded_absname
;
2859 Lisp_Object user
= CAR_SAFE (context
);
2860 Lisp_Object role
= CAR_SAFE (CDR_SAFE (context
));
2861 Lisp_Object type
= CAR_SAFE (CDR_SAFE (CDR_SAFE (context
)));
2862 Lisp_Object range
= CAR_SAFE (CDR_SAFE (CDR_SAFE (CDR_SAFE (context
))));
2863 security_context_t con
;
2866 context_t parsed_con
;
2869 absname
= Fexpand_file_name (filename
, BVAR (current_buffer
, directory
));
2871 /* If the file name has special constructs in it,
2872 call the corresponding file handler. */
2873 handler
= Ffind_file_name_handler (absname
, Qset_file_selinux_context
);
2874 if (!NILP (handler
))
2875 return call3 (handler
, Qset_file_selinux_context
, absname
, context
);
2878 if (is_selinux_enabled ())
2880 /* Get current file context. */
2881 encoded_absname
= ENCODE_FILE (absname
);
2882 conlength
= lgetfilecon (SSDATA (encoded_absname
), &con
);
2885 parsed_con
= context_new (con
);
2886 /* Change the parts defined in the parameter.*/
2889 if (context_user_set (parsed_con
, SSDATA (user
)))
2890 error ("Doing context_user_set");
2894 if (context_role_set (parsed_con
, SSDATA (role
)))
2895 error ("Doing context_role_set");
2899 if (context_type_set (parsed_con
, SSDATA (type
)))
2900 error ("Doing context_type_set");
2902 if (STRINGP (range
))
2904 if (context_range_set (parsed_con
, SSDATA (range
)))
2905 error ("Doing context_range_set");
2908 /* Set the modified context back to the file. */
2909 fail
= (lsetfilecon (SSDATA (encoded_absname
),
2910 context_str (parsed_con
))
2912 /* See http://debbugs.gnu.org/11245 for ENOTSUP. */
2913 if (fail
&& errno
!= ENOTSUP
)
2914 report_file_error ("Doing lsetfilecon", absname
);
2916 context_free (parsed_con
);
2918 return fail
? Qnil
: Qt
;
2921 report_file_error ("Doing lgetfilecon", absname
);
2928 DEFUN ("file-acl", Ffile_acl
, Sfile_acl
, 1, 1, 0,
2929 doc
: /* Return ACL entries of file named FILENAME.
2930 The entries are returned in a format suitable for use in `set-file-acl'
2931 but is otherwise undocumented and subject to change.
2932 Return nil if file does not exist or is not accessible, or if Emacs
2933 was unable to determine the ACL entries. */)
2934 (Lisp_Object filename
)
2937 Lisp_Object absname
;
2938 Lisp_Object handler
;
2939 # ifdef HAVE_ACL_SET_FILE
2941 Lisp_Object acl_string
;
2943 # ifndef HAVE_ACL_TYPE_EXTENDED
2944 acl_type_t ACL_TYPE_EXTENDED
= ACL_TYPE_ACCESS
;
2948 absname
= expand_and_dir_to_file (filename
,
2949 BVAR (current_buffer
, directory
));
2951 /* If the file name has special constructs in it,
2952 call the corresponding file handler. */
2953 handler
= Ffind_file_name_handler (absname
, Qfile_acl
);
2954 if (!NILP (handler
))
2955 return call2 (handler
, Qfile_acl
, absname
);
2957 # ifdef HAVE_ACL_SET_FILE
2958 absname
= ENCODE_FILE (absname
);
2960 acl
= acl_get_file (SSDATA (absname
), ACL_TYPE_EXTENDED
);
2964 str
= acl_to_text (acl
, NULL
);
2971 acl_string
= build_string (str
);
2982 DEFUN ("set-file-acl", Fset_file_acl
, Sset_file_acl
,
2984 doc
: /* Set ACL of file named FILENAME to ACL-STRING.
2985 ACL-STRING should contain the textual representation of the ACL
2986 entries in a format suitable for the platform.
2988 Value is t if setting of ACL was successful, nil otherwise.
2990 Setting ACL for local files requires Emacs to be built with ACL
2992 (Lisp_Object filename
, Lisp_Object acl_string
)
2995 Lisp_Object absname
;
2996 Lisp_Object handler
;
2997 # ifdef HAVE_ACL_SET_FILE
2998 Lisp_Object encoded_absname
;
3003 absname
= Fexpand_file_name (filename
, BVAR (current_buffer
, directory
));
3005 /* If the file name has special constructs in it,
3006 call the corresponding file handler. */
3007 handler
= Ffind_file_name_handler (absname
, Qset_file_acl
);
3008 if (!NILP (handler
))
3009 return call3 (handler
, Qset_file_acl
, absname
, acl_string
);
3011 # ifdef HAVE_ACL_SET_FILE
3012 if (STRINGP (acl_string
))
3014 acl
= acl_from_text (SSDATA (acl_string
));
3017 report_file_error ("Converting ACL", absname
);
3021 encoded_absname
= ENCODE_FILE (absname
);
3023 fail
= (acl_set_file (SSDATA (encoded_absname
), ACL_TYPE_ACCESS
,
3026 if (fail
&& acl_errno_valid (errno
))
3027 report_file_error ("Setting ACL", absname
);
3030 return fail
? Qnil
: Qt
;
3038 DEFUN ("file-modes", Ffile_modes
, Sfile_modes
, 1, 1, 0,
3039 doc
: /* Return mode bits of file named FILENAME, as an integer.
3040 Return nil, if file does not exist or is not accessible. */)
3041 (Lisp_Object filename
)
3043 Lisp_Object absname
;
3045 Lisp_Object handler
;
3047 absname
= expand_and_dir_to_file (filename
, BVAR (current_buffer
, directory
));
3049 /* If the file name has special constructs in it,
3050 call the corresponding file handler. */
3051 handler
= Ffind_file_name_handler (absname
, Qfile_modes
);
3052 if (!NILP (handler
))
3053 return call2 (handler
, Qfile_modes
, absname
);
3055 absname
= ENCODE_FILE (absname
);
3057 if (stat (SSDATA (absname
), &st
) < 0)
3060 return make_number (st
.st_mode
& 07777);
3063 DEFUN ("set-file-modes", Fset_file_modes
, Sset_file_modes
, 2, 2,
3064 "(let ((file (read-file-name \"File: \"))) \
3065 (list file (read-file-modes nil file)))",
3066 doc
: /* Set mode bits of file named FILENAME to MODE (an integer).
3067 Only the 12 low bits of MODE are used.
3069 Interactively, mode bits are read by `read-file-modes', which accepts
3070 symbolic notation, like the `chmod' command from GNU Coreutils. */)
3071 (Lisp_Object filename
, Lisp_Object mode
)
3073 Lisp_Object absname
, encoded_absname
;
3074 Lisp_Object handler
;
3076 absname
= Fexpand_file_name (filename
, BVAR (current_buffer
, directory
));
3077 CHECK_NUMBER (mode
);
3079 /* If the file name has special constructs in it,
3080 call the corresponding file handler. */
3081 handler
= Ffind_file_name_handler (absname
, Qset_file_modes
);
3082 if (!NILP (handler
))
3083 return call3 (handler
, Qset_file_modes
, absname
, mode
);
3085 encoded_absname
= ENCODE_FILE (absname
);
3087 if (chmod (SSDATA (encoded_absname
), XINT (mode
) & 07777) < 0)
3088 report_file_error ("Doing chmod", absname
);
3093 DEFUN ("set-default-file-modes", Fset_default_file_modes
, Sset_default_file_modes
, 1, 1, 0,
3094 doc
: /* Set the file permission bits for newly created files.
3095 The argument MODE should be an integer; only the low 9 bits are used.
3096 This setting is inherited by subprocesses. */)
3099 mode_t oldrealmask
, oldumask
, newumask
;
3100 CHECK_NUMBER (mode
);
3101 oldrealmask
= realmask
;
3102 newumask
= ~ XINT (mode
) & 0777;
3105 realmask
= newumask
;
3106 oldumask
= umask (newumask
);
3109 eassert (oldumask
== oldrealmask
);
3113 DEFUN ("default-file-modes", Fdefault_file_modes
, Sdefault_file_modes
, 0, 0, 0,
3114 doc
: /* Return the default file protection for created files.
3115 The value is an integer. */)
3119 XSETINT (value
, (~ realmask
) & 0777);
3124 DEFUN ("set-file-times", Fset_file_times
, Sset_file_times
, 1, 2, 0,
3125 doc
: /* Set times of file FILENAME to TIMESTAMP.
3126 Set both access and modification times.
3127 Return t on success, else nil.
3128 Use the current time if TIMESTAMP is nil. TIMESTAMP is in the format of
3130 (Lisp_Object filename
, Lisp_Object timestamp
)
3132 Lisp_Object absname
, encoded_absname
;
3133 Lisp_Object handler
;
3134 struct timespec t
= lisp_time_argument (timestamp
);
3136 absname
= Fexpand_file_name (filename
, BVAR (current_buffer
, directory
));
3138 /* If the file name has special constructs in it,
3139 call the corresponding file handler. */
3140 handler
= Ffind_file_name_handler (absname
, Qset_file_times
);
3141 if (!NILP (handler
))
3142 return call3 (handler
, Qset_file_times
, absname
, timestamp
);
3144 encoded_absname
= ENCODE_FILE (absname
);
3147 if (set_file_times (-1, SSDATA (encoded_absname
), t
, t
) != 0)
3150 /* Setting times on a directory always fails. */
3151 if (file_directory_p (SSDATA (encoded_absname
)))
3154 report_file_error ("Setting file times", absname
);
3162 DEFUN ("unix-sync", Funix_sync
, Sunix_sync
, 0, 0, "",
3163 doc
: /* Tell Unix to finish all pending disk updates. */)
3170 #endif /* HAVE_SYNC */
3172 DEFUN ("file-newer-than-file-p", Ffile_newer_than_file_p
, Sfile_newer_than_file_p
, 2, 2, 0,
3173 doc
: /* Return t if file FILE1 is newer than file FILE2.
3174 If FILE1 does not exist, the answer is nil;
3175 otherwise, if FILE2 does not exist, the answer is t. */)
3176 (Lisp_Object file1
, Lisp_Object file2
)
3178 Lisp_Object absname1
, absname2
;
3179 struct stat st1
, st2
;
3180 Lisp_Object handler
;
3182 CHECK_STRING (file1
);
3183 CHECK_STRING (file2
);
3186 absname1
= expand_and_dir_to_file (file1
, BVAR (current_buffer
, directory
));
3187 absname2
= expand_and_dir_to_file (file2
, BVAR (current_buffer
, directory
));
3189 /* If the file name has special constructs in it,
3190 call the corresponding file handler. */
3191 handler
= Ffind_file_name_handler (absname1
, Qfile_newer_than_file_p
);
3193 handler
= Ffind_file_name_handler (absname2
, Qfile_newer_than_file_p
);
3194 if (!NILP (handler
))
3195 return call3 (handler
, Qfile_newer_than_file_p
, absname1
, absname2
);
3197 absname1
= ENCODE_FILE (absname1
);
3198 absname2
= ENCODE_FILE (absname2
);
3200 if (stat (SSDATA (absname1
), &st1
) < 0)
3203 if (stat (SSDATA (absname2
), &st2
) < 0)
3206 return (timespec_cmp (get_stat_mtime (&st2
), get_stat_mtime (&st1
)) < 0
3210 #ifndef READ_BUF_SIZE
3211 #define READ_BUF_SIZE (64 << 10)
3213 /* Some buffer offsets are stored in 'int' variables. */
3214 verify (READ_BUF_SIZE
<= INT_MAX
);
3216 /* This function is called after Lisp functions to decide a coding
3217 system are called, or when they cause an error. Before they are
3218 called, the current buffer is set unibyte and it contains only a
3219 newly inserted text (thus the buffer was empty before the
3222 The functions may set markers, overlays, text properties, or even
3223 alter the buffer contents, change the current buffer.
3225 Here, we reset all those changes by:
3226 o set back the current buffer.
3227 o move all markers and overlays to BEG.
3228 o remove all text properties.
3229 o set back the buffer multibyteness. */
3232 decide_coding_unwind (Lisp_Object unwind_data
)
3234 Lisp_Object multibyte
, undo_list
, buffer
;
3236 multibyte
= XCAR (unwind_data
);
3237 unwind_data
= XCDR (unwind_data
);
3238 undo_list
= XCAR (unwind_data
);
3239 buffer
= XCDR (unwind_data
);
3241 set_buffer_internal (XBUFFER (buffer
));
3242 adjust_markers_for_delete (BEG
, BEG_BYTE
, Z
, Z_BYTE
);
3243 adjust_overlays_for_delete (BEG
, Z
- BEG
);
3244 set_buffer_intervals (current_buffer
, NULL
);
3245 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
3247 /* Now we are safe to change the buffer's multibyteness directly. */
3248 bset_enable_multibyte_characters (current_buffer
, multibyte
);
3249 bset_undo_list (current_buffer
, undo_list
);
3252 /* Read from a non-regular file. STATE is a Lisp_Save_Value
3253 object where slot 0 is the file descriptor, slot 1 specifies
3254 an offset to put the read bytes, and slot 2 is the maximum
3255 amount of bytes to read. Value is the number of bytes read. */
3258 read_non_regular (Lisp_Object state
)
3264 nbytes
= emacs_read (XSAVE_INTEGER (state
, 0),
3265 ((char *) BEG_ADDR
+ PT_BYTE
- BEG_BYTE
3266 + XSAVE_INTEGER (state
, 1)),
3267 XSAVE_INTEGER (state
, 2));
3269 /* Fast recycle this object for the likely next call. */
3271 return make_number (nbytes
);
3275 /* Condition-case handler used when reading from non-regular files
3276 in insert-file-contents. */
3279 read_non_regular_quit (Lisp_Object ignore
)
3284 /* Return the file offset that VAL represents, checking for type
3285 errors and overflow. */
3287 file_offset (Lisp_Object val
)
3289 if (RANGED_INTEGERP (0, val
, TYPE_MAXIMUM (off_t
)))
3294 double v
= XFLOAT_DATA (val
);
3296 && (sizeof (off_t
) < sizeof v
3297 ? v
<= TYPE_MAXIMUM (off_t
)
3298 : v
< TYPE_MAXIMUM (off_t
)))
3302 wrong_type_argument (intern ("file-offset"), val
);
3305 /* Return a special time value indicating the error number ERRNUM. */
3306 static struct timespec
3307 time_error_value (int errnum
)
3309 int ns
= (errnum
== ENOENT
|| errnum
== EACCES
|| errnum
== ENOTDIR
3310 ? NONEXISTENT_MODTIME_NSECS
3311 : UNKNOWN_MODTIME_NSECS
);
3312 return make_timespec (0, ns
);
3316 get_window_points_and_markers (void)
3318 Lisp_Object pt_marker
= Fpoint_marker ();
3320 = call3 (Qget_buffer_window_list
, Fcurrent_buffer (), Qnil
, Qt
);
3321 Lisp_Object window_markers
= windows
;
3322 /* Window markers (and point) are handled specially: rather than move to
3323 just before or just after the modified text, we try to keep the
3324 markers at the same distance (bug#19161).
3325 In general, this is wrong, but for window-markers, this should be harmless
3326 and is convenient for the end user when most of the file is unmodified,
3327 except for a few minor details near the beginning and near the end. */
3328 for (; CONSP (windows
); windows
= XCDR (windows
))
3329 if (WINDOWP (XCAR (windows
)))
3331 Lisp_Object window_marker
= XWINDOW (XCAR (windows
))->pointm
;
3333 Fcons (window_marker
, Fmarker_position (window_marker
)));
3335 return Fcons (Fcons (pt_marker
, Fpoint ()), window_markers
);
3339 restore_window_points (Lisp_Object window_markers
, ptrdiff_t inserted
,
3340 ptrdiff_t same_at_start
, ptrdiff_t same_at_end
)
3342 for (; CONSP (window_markers
); window_markers
= XCDR (window_markers
))
3343 if (CONSP (XCAR (window_markers
)))
3345 Lisp_Object car
= XCAR (window_markers
);
3346 Lisp_Object marker
= XCAR (car
);
3347 Lisp_Object oldpos
= XCDR (car
);
3348 if (MARKERP (marker
) && INTEGERP (oldpos
)
3349 && XINT (oldpos
) > same_at_start
3350 && XINT (oldpos
) < same_at_end
)
3352 ptrdiff_t oldsize
= same_at_end
- same_at_start
;
3353 ptrdiff_t newsize
= inserted
;
3354 double growth
= newsize
/ (double)oldsize
;
3356 = same_at_start
+ growth
* (XINT (oldpos
) - same_at_start
);
3357 Fset_marker (marker
, make_number (newpos
), Qnil
);
3362 /* FIXME: insert-file-contents should be split with the top-level moved to
3363 Elisp and only the core kept in C. */
3365 DEFUN ("insert-file-contents", Finsert_file_contents
, Sinsert_file_contents
,
3367 doc
: /* Insert contents of file FILENAME after point.
3368 Returns list of absolute file name and number of characters inserted.
3369 If second argument VISIT is non-nil, the buffer's visited filename and
3370 last save file modtime are set, and it is marked unmodified. If
3371 visiting and the file does not exist, visiting is completed before the
3374 The optional third and fourth arguments BEG and END specify what portion
3375 of the file to insert. These arguments count bytes in the file, not
3376 characters in the buffer. If VISIT is non-nil, BEG and END must be nil.
3378 If optional fifth argument REPLACE is non-nil, replace the current
3379 buffer contents (in the accessible portion) with the file contents.
3380 This is better than simply deleting and inserting the whole thing
3381 because (1) it preserves some marker positions and (2) it puts less data
3382 in the undo list. When REPLACE is non-nil, the second return value is
3383 the number of characters that replace previous buffer contents.
3385 This function does code conversion according to the value of
3386 `coding-system-for-read' or `file-coding-system-alist', and sets the
3387 variable `last-coding-system-used' to the coding system actually used.
3389 In addition, this function decodes the inserted text from known formats
3390 by calling `format-decode', which see. */)
3391 (Lisp_Object filename
, Lisp_Object visit
, Lisp_Object beg
, Lisp_Object end
, Lisp_Object replace
)
3394 struct timespec mtime
;
3396 ptrdiff_t inserted
= 0;
3398 off_t beg_offset
, end_offset
;
3400 ptrdiff_t count
= SPECPDL_INDEX ();
3401 Lisp_Object handler
, val
, insval
, orig_filename
, old_undo
;
3403 ptrdiff_t total
= 0;
3404 bool not_regular
= 0;
3406 char read_buf
[READ_BUF_SIZE
];
3407 struct coding_system coding
;
3408 bool replace_handled
= false;
3409 bool set_coding_system
= false;
3410 Lisp_Object coding_system
;
3411 bool read_quit
= false;
3412 /* If the undo log only contains the insertion, there's no point
3413 keeping it. It's typically when we first fill a file-buffer. */
3414 bool empty_undo_list_p
3415 = (!NILP (visit
) && NILP (BVAR (current_buffer
, undo_list
))
3417 Lisp_Object old_Vdeactivate_mark
= Vdeactivate_mark
;
3418 bool we_locked_file
= false;
3420 Lisp_Object window_markers
= Qnil
;
3421 /* same_at_start and same_at_end count bytes, because file access counts
3422 bytes and BEG and END count bytes. */
3423 ptrdiff_t same_at_start
= BEGV_BYTE
;
3424 ptrdiff_t same_at_end
= ZV_BYTE
;
3425 /* SAME_AT_END_CHARPOS counts characters, because
3426 restore_window_points needs the old character count. */
3427 ptrdiff_t same_at_end_charpos
= ZV
;
3429 if (current_buffer
->base_buffer
&& ! NILP (visit
))
3430 error ("Cannot do file visiting in an indirect buffer");
3432 if (!NILP (BVAR (current_buffer
, read_only
)))
3433 Fbarf_if_buffer_read_only (Qnil
);
3437 orig_filename
= Qnil
;
3440 CHECK_STRING (filename
);
3441 filename
= Fexpand_file_name (filename
, Qnil
);
3443 /* The value Qnil means that the coding system is not yet
3445 coding_system
= Qnil
;
3447 /* If the file name has special constructs in it,
3448 call the corresponding file handler. */
3449 handler
= Ffind_file_name_handler (filename
, Qinsert_file_contents
);
3450 if (!NILP (handler
))
3452 val
= call6 (handler
, Qinsert_file_contents
, filename
,
3453 visit
, beg
, end
, replace
);
3454 if (CONSP (val
) && CONSP (XCDR (val
))
3455 && RANGED_INTEGERP (0, XCAR (XCDR (val
)), ZV
- PT
))
3456 inserted
= XINT (XCAR (XCDR (val
)));
3460 orig_filename
= filename
;
3461 filename
= ENCODE_FILE (filename
);
3463 fd
= emacs_open (SSDATA (filename
), O_RDONLY
, 0);
3468 report_file_error ("Opening input file", orig_filename
);
3469 mtime
= time_error_value (save_errno
);
3471 if (!NILP (Vcoding_system_for_read
))
3473 /* Don't let invalid values into buffer-file-coding-system. */
3474 CHECK_CODING_SYSTEM (Vcoding_system_for_read
);
3475 Fset (Qbuffer_file_coding_system
, Vcoding_system_for_read
);
3480 fd_index
= SPECPDL_INDEX ();
3481 record_unwind_protect_int (close_file_unwind
, fd
);
3483 /* Replacement should preserve point as it preserves markers. */
3484 if (!NILP (replace
))
3486 window_markers
= get_window_points_and_markers ();
3487 record_unwind_protect (restore_point_unwind
,
3488 XCAR (XCAR (window_markers
)));
3491 if (fstat (fd
, &st
) != 0)
3492 report_file_error ("Input file status", orig_filename
);
3493 mtime
= get_stat_mtime (&st
);
3495 /* This code will need to be changed in order to work on named
3496 pipes, and it's probably just not worth it. So we should at
3497 least signal an error. */
3498 if (!S_ISREG (st
.st_mode
))
3505 if (! NILP (replace
) || ! NILP (beg
) || ! NILP (end
))
3506 xsignal2 (Qfile_error
,
3507 build_string ("not a regular file"), orig_filename
);
3512 if (!NILP (beg
) || !NILP (end
))
3513 error ("Attempt to visit less than an entire file");
3514 if (BEG
< Z
&& NILP (replace
))
3515 error ("Cannot do file visiting in a non-empty buffer");
3519 beg_offset
= file_offset (beg
);
3524 end_offset
= file_offset (end
);
3528 end_offset
= TYPE_MAXIMUM (off_t
);
3531 end_offset
= st
.st_size
;
3533 /* A negative size can happen on a platform that allows file
3534 sizes greater than the maximum off_t value. */
3538 /* The file size returned from stat may be zero, but data
3539 may be readable nonetheless, for example when this is a
3540 file in the /proc filesystem. */
3541 if (end_offset
== 0)
3542 end_offset
= READ_BUF_SIZE
;
3546 /* Check now whether the buffer will become too large,
3547 in the likely case where the file's length is not changing.
3548 This saves a lot of needless work before a buffer overflow. */
3551 /* The likely offset where we will stop reading. We could read
3552 more (or less), if the file grows (or shrinks) as we read it. */
3553 off_t likely_end
= min (end_offset
, st
.st_size
);
3555 if (beg_offset
< likely_end
)
3558 = Z_BYTE
- (!NILP (replace
) ? ZV_BYTE
- BEGV_BYTE
: 0);
3559 ptrdiff_t buf_growth_max
= BUF_BYTES_MAX
- buf_bytes
;
3560 off_t likely_growth
= likely_end
- beg_offset
;
3561 if (buf_growth_max
< likely_growth
)
3566 /* Prevent redisplay optimizations. */
3567 current_buffer
->clip_changed
= true;
3569 if (EQ (Vcoding_system_for_read
, Qauto_save_coding
))
3571 coding_system
= coding_inherit_eol_type (Qutf_8_emacs
, Qunix
);
3572 setup_coding_system (coding_system
, &coding
);
3573 /* Ensure we set Vlast_coding_system_used. */
3574 set_coding_system
= true;
3578 /* Decide the coding system to use for reading the file now
3579 because we can't use an optimized method for handling
3580 `coding:' tag if the current buffer is not empty. */
3581 if (!NILP (Vcoding_system_for_read
))
3582 coding_system
= Vcoding_system_for_read
;
3585 /* Don't try looking inside a file for a coding system
3586 specification if it is not seekable. */
3587 if (! not_regular
&& ! NILP (Vset_auto_coding_function
))
3589 /* Find a coding system specified in the heading two
3590 lines or in the tailing several lines of the file.
3591 We assume that the 1K-byte and 3K-byte for heading
3592 and tailing respectively are sufficient for this
3596 if (st
.st_size
<= (1024 * 4))
3597 nread
= emacs_read (fd
, read_buf
, 1024 * 4);
3600 nread
= emacs_read (fd
, read_buf
, 1024);
3604 if (lseek (fd
, - (1024 * 3), SEEK_END
) < 0)
3605 report_file_error ("Setting file position",
3607 ntail
= emacs_read (fd
, read_buf
+ nread
, 1024 * 3);
3608 nread
= ntail
< 0 ? ntail
: nread
+ ntail
;
3613 report_file_error ("Read error", orig_filename
);
3616 AUTO_STRING (name
, " *code-converting-work*");
3617 struct buffer
*prev
= current_buffer
;
3618 Lisp_Object workbuf
;
3621 record_unwind_current_buffer ();
3623 workbuf
= Fget_buffer_create (name
);
3624 buf
= XBUFFER (workbuf
);
3626 delete_all_overlays (buf
);
3627 bset_directory (buf
, BVAR (current_buffer
, directory
));
3628 bset_read_only (buf
, Qnil
);
3629 bset_filename (buf
, Qnil
);
3630 bset_undo_list (buf
, Qt
);
3631 eassert (buf
->overlays_before
== NULL
);
3632 eassert (buf
->overlays_after
== NULL
);
3634 set_buffer_internal (buf
);
3636 bset_enable_multibyte_characters (buf
, Qnil
);
3638 insert_1_both ((char *) read_buf
, nread
, nread
, 0, 0, 0);
3639 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
3640 coding_system
= call2 (Vset_auto_coding_function
,
3641 filename
, make_number (nread
));
3642 set_buffer_internal (prev
);
3644 /* Discard the unwind protect for recovering the
3648 /* Rewind the file for the actual read done later. */
3649 if (lseek (fd
, 0, SEEK_SET
) < 0)
3650 report_file_error ("Setting file position", orig_filename
);
3654 if (NILP (coding_system
))
3656 /* If we have not yet decided a coding system, check
3657 file-coding-system-alist. */
3658 coding_system
= CALLN (Ffind_operation_coding_system
,
3659 Qinsert_file_contents
, orig_filename
,
3660 visit
, beg
, end
, replace
);
3661 if (CONSP (coding_system
))
3662 coding_system
= XCAR (coding_system
);
3666 if (NILP (coding_system
))
3667 coding_system
= Qundecided
;
3669 CHECK_CODING_SYSTEM (coding_system
);
3671 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3672 /* We must suppress all character code conversion except for
3673 end-of-line conversion. */
3674 coding_system
= raw_text_coding_system (coding_system
);
3676 setup_coding_system (coding_system
, &coding
);
3677 /* Ensure we set Vlast_coding_system_used. */
3678 set_coding_system
= true;
3681 /* If requested, replace the accessible part of the buffer
3682 with the file contents. Avoid replacing text at the
3683 beginning or end of the buffer that matches the file contents;
3684 that preserves markers pointing to the unchanged parts.
3686 Here we implement this feature in an optimized way
3687 for the case where code conversion is NOT needed.
3688 The following if-statement handles the case of conversion
3689 in a less optimal way.
3691 If the code conversion is "automatic" then we try using this
3692 method and hope for the best.
3693 But if we discover the need for conversion, we give up on this method
3694 and let the following if-statement handle the replace job. */
3697 && (NILP (coding_system
)
3698 || ! CODING_REQUIRE_DECODING (&coding
)))
3701 /* There is still a possibility we will find the need to do code
3702 conversion. If that happens, set this variable to
3703 give up on handling REPLACE in the optimized way. */
3704 bool giveup_match_end
= false;
3706 if (beg_offset
!= 0)
3708 if (lseek (fd
, beg_offset
, SEEK_SET
) < 0)
3709 report_file_error ("Setting file position", orig_filename
);
3714 /* Count how many chars at the start of the file
3715 match the text at the beginning of the buffer. */
3720 nread
= emacs_read (fd
, read_buf
, sizeof read_buf
);
3722 report_file_error ("Read error", orig_filename
);
3723 else if (nread
== 0)
3726 if (CODING_REQUIRE_DETECTION (&coding
))
3728 coding_system
= detect_coding_system ((unsigned char *) read_buf
,
3731 setup_coding_system (coding_system
, &coding
);
3734 if (CODING_REQUIRE_DECODING (&coding
))
3735 /* We found that the file should be decoded somehow.
3736 Let's give up here. */
3738 giveup_match_end
= true;
3743 while (bufpos
< nread
&& same_at_start
< ZV_BYTE
3744 && FETCH_BYTE (same_at_start
) == read_buf
[bufpos
])
3745 same_at_start
++, bufpos
++;
3746 /* If we found a discrepancy, stop the scan.
3747 Otherwise loop around and scan the next bufferful. */
3748 if (bufpos
!= nread
)
3751 immediate_quit
= false;
3752 /* If the file matches the buffer completely,
3753 there's no need to replace anything. */
3754 if (same_at_start
- BEGV_BYTE
== end_offset
- beg_offset
)
3757 clear_unwind_protect (fd_index
);
3759 /* Truncate the buffer to the size of the file. */
3760 del_range_1 (same_at_start
, same_at_end
, 0, 0);
3763 immediate_quit
= true;
3765 /* Count how many chars at the end of the file
3766 match the text at the end of the buffer. But, if we have
3767 already found that decoding is necessary, don't waste time. */
3768 while (!giveup_match_end
)
3770 int total_read
, nread
, bufpos
, trial
;
3773 /* At what file position are we now scanning? */
3774 curpos
= end_offset
- (ZV_BYTE
- same_at_end
);
3775 /* If the entire file matches the buffer tail, stop the scan. */
3778 /* How much can we scan in the next step? */
3779 trial
= min (curpos
, sizeof read_buf
);
3780 if (lseek (fd
, curpos
- trial
, SEEK_SET
) < 0)
3781 report_file_error ("Setting file position", orig_filename
);
3783 total_read
= nread
= 0;
3784 while (total_read
< trial
)
3786 nread
= emacs_read (fd
, read_buf
+ total_read
, trial
- total_read
);
3788 report_file_error ("Read error", orig_filename
);
3789 else if (nread
== 0)
3791 total_read
+= nread
;
3794 /* Scan this bufferful from the end, comparing with
3795 the Emacs buffer. */
3796 bufpos
= total_read
;
3798 /* Compare with same_at_start to avoid counting some buffer text
3799 as matching both at the file's beginning and at the end. */
3800 while (bufpos
> 0 && same_at_end
> same_at_start
3801 && FETCH_BYTE (same_at_end
- 1) == read_buf
[bufpos
- 1])
3802 same_at_end
--, bufpos
--;
3804 /* If we found a discrepancy, stop the scan.
3805 Otherwise loop around and scan the preceding bufferful. */
3808 /* If this discrepancy is because of code conversion,
3809 we cannot use this method; giveup and try the other. */
3810 if (same_at_end
> same_at_start
3811 && FETCH_BYTE (same_at_end
- 1) >= 0200
3812 && ! NILP (BVAR (current_buffer
, enable_multibyte_characters
))
3813 && (CODING_MAY_REQUIRE_DECODING (&coding
)))
3814 giveup_match_end
= true;
3823 if (! giveup_match_end
)
3827 /* We win! We can handle REPLACE the optimized way. */
3829 /* Extend the start of non-matching text area to multibyte
3830 character boundary. */
3831 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3832 while (same_at_start
> BEGV_BYTE
3833 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_start
)))
3836 /* Extend the end of non-matching text area to multibyte
3837 character boundary. */
3838 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3839 while (same_at_end
< ZV_BYTE
3840 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_end
)))
3843 /* Don't try to reuse the same piece of text twice. */
3844 overlap
= (same_at_start
- BEGV_BYTE
3846 + (! NILP (end
) ? end_offset
: st
.st_size
) - ZV_BYTE
));
3848 same_at_end
+= overlap
;
3849 same_at_end_charpos
= BYTE_TO_CHAR (same_at_end
);
3851 /* Arrange to read only the nonmatching middle part of the file. */
3852 beg_offset
+= same_at_start
- BEGV_BYTE
;
3853 end_offset
-= ZV_BYTE
- same_at_end
;
3855 invalidate_buffer_caches (current_buffer
,
3856 BYTE_TO_CHAR (same_at_start
),
3857 same_at_end_charpos
);
3858 del_range_byte (same_at_start
, same_at_end
, 0);
3859 /* Insert from the file at the proper position. */
3860 temp
= BYTE_TO_CHAR (same_at_start
);
3861 SET_PT_BOTH (temp
, same_at_start
);
3863 /* If display currently starts at beginning of line,
3864 keep it that way. */
3865 if (XBUFFER (XWINDOW (selected_window
)->contents
) == current_buffer
)
3866 XWINDOW (selected_window
)->start_at_line_beg
= !NILP (Fbolp ());
3868 replace_handled
= true;
3872 /* If requested, replace the accessible part of the buffer
3873 with the file contents. Avoid replacing text at the
3874 beginning or end of the buffer that matches the file contents;
3875 that preserves markers pointing to the unchanged parts.
3877 Here we implement this feature for the case where code conversion
3878 is needed, in a simple way that needs a lot of memory.
3879 The preceding if-statement handles the case of no conversion
3880 in a more optimized way. */
3881 if (!NILP (replace
) && ! replace_handled
&& BEGV
< ZV
)
3883 ptrdiff_t same_at_start_charpos
;
3884 ptrdiff_t inserted_chars
;
3887 unsigned char *decoded
;
3890 ptrdiff_t this_count
= SPECPDL_INDEX ();
3892 = ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
3893 Lisp_Object conversion_buffer
;
3895 conversion_buffer
= code_conversion_save (1, multibyte
);
3897 /* First read the whole file, performing code conversion into
3898 CONVERSION_BUFFER. */
3900 if (lseek (fd
, beg_offset
, SEEK_SET
) < 0)
3901 report_file_error ("Setting file position", orig_filename
);
3903 inserted
= 0; /* Bytes put into CONVERSION_BUFFER so far. */
3904 unprocessed
= 0; /* Bytes not processed in previous loop. */
3908 /* Read at most READ_BUF_SIZE bytes at a time, to allow
3909 quitting while reading a huge file. */
3911 /* Allow quitting out of the actual I/O. */
3914 this = emacs_read (fd
, read_buf
+ unprocessed
,
3915 READ_BUF_SIZE
- unprocessed
);
3921 BUF_TEMP_SET_PT (XBUFFER (conversion_buffer
),
3922 BUF_Z (XBUFFER (conversion_buffer
)));
3923 decode_coding_c_string (&coding
, (unsigned char *) read_buf
,
3924 unprocessed
+ this, conversion_buffer
);
3925 unprocessed
= coding
.carryover_bytes
;
3926 if (coding
.carryover_bytes
> 0)
3927 memcpy (read_buf
, coding
.carryover
, unprocessed
);
3931 report_file_error ("Read error", orig_filename
);
3933 clear_unwind_protect (fd_index
);
3935 if (unprocessed
> 0)
3937 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
3938 decode_coding_c_string (&coding
, (unsigned char *) read_buf
,
3939 unprocessed
, conversion_buffer
);
3940 coding
.mode
&= ~CODING_MODE_LAST_BLOCK
;
3943 coding_system
= CODING_ID_NAME (coding
.id
);
3944 set_coding_system
= true;
3945 decoded
= BUF_BEG_ADDR (XBUFFER (conversion_buffer
));
3946 inserted
= (BUF_Z_BYTE (XBUFFER (conversion_buffer
))
3947 - BUF_BEG_BYTE (XBUFFER (conversion_buffer
)));
3949 /* Compare the beginning of the converted string with the buffer
3953 while (bufpos
< inserted
&& same_at_start
< same_at_end
3954 && FETCH_BYTE (same_at_start
) == decoded
[bufpos
])
3955 same_at_start
++, bufpos
++;
3957 /* If the file matches the head of buffer completely,
3958 there's no need to replace anything. */
3960 if (bufpos
== inserted
)
3962 /* Truncate the buffer to the size of the file. */
3963 if (same_at_start
!= same_at_end
)
3965 invalidate_buffer_caches (current_buffer
,
3966 BYTE_TO_CHAR (same_at_start
),
3967 BYTE_TO_CHAR (same_at_end
));
3968 del_range_byte (same_at_start
, same_at_end
, 0);
3972 unbind_to (this_count
, Qnil
);
3976 /* Extend the start of non-matching text area to the previous
3977 multibyte character boundary. */
3978 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3979 while (same_at_start
> BEGV_BYTE
3980 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_start
)))
3983 /* Scan this bufferful from the end, comparing with
3984 the Emacs buffer. */
3987 /* Compare with same_at_start to avoid counting some buffer text
3988 as matching both at the file's beginning and at the end. */
3989 while (bufpos
> 0 && same_at_end
> same_at_start
3990 && FETCH_BYTE (same_at_end
- 1) == decoded
[bufpos
- 1])
3991 same_at_end
--, bufpos
--;
3993 /* Extend the end of non-matching text area to the next
3994 multibyte character boundary. */
3995 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3996 while (same_at_end
< ZV_BYTE
3997 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_end
)))
4000 /* Don't try to reuse the same piece of text twice. */
4001 overlap
= same_at_start
- BEGV_BYTE
- (same_at_end
+ inserted
- ZV_BYTE
);
4003 same_at_end
+= overlap
;
4004 same_at_end_charpos
= BYTE_TO_CHAR (same_at_end
);
4006 /* If display currently starts at beginning of line,
4007 keep it that way. */
4008 if (XBUFFER (XWINDOW (selected_window
)->contents
) == current_buffer
)
4009 XWINDOW (selected_window
)->start_at_line_beg
= !NILP (Fbolp ());
4011 /* Replace the chars that we need to replace,
4012 and update INSERTED to equal the number of bytes
4013 we are taking from the decoded string. */
4014 inserted
-= (ZV_BYTE
- same_at_end
) + (same_at_start
- BEGV_BYTE
);
4016 if (same_at_end
!= same_at_start
)
4018 invalidate_buffer_caches (current_buffer
,
4019 BYTE_TO_CHAR (same_at_start
),
4020 same_at_end_charpos
);
4021 del_range_byte (same_at_start
, same_at_end
, 0);
4023 eassert (same_at_start
== GPT_BYTE
);
4024 same_at_start
= GPT_BYTE
;
4028 temp
= same_at_end_charpos
;
4030 /* Insert from the file at the proper position. */
4031 SET_PT_BOTH (temp
, same_at_start
);
4032 same_at_start_charpos
4033 = buf_bytepos_to_charpos (XBUFFER (conversion_buffer
),
4034 same_at_start
- BEGV_BYTE
4035 + BUF_BEG_BYTE (XBUFFER (conversion_buffer
)));
4036 eassert (same_at_start_charpos
== temp
- (BEGV
- BEG
));
4038 = (buf_bytepos_to_charpos (XBUFFER (conversion_buffer
),
4039 same_at_start
+ inserted
- BEGV_BYTE
4040 + BUF_BEG_BYTE (XBUFFER (conversion_buffer
)))
4041 - same_at_start_charpos
);
4042 /* This binding is to avoid ask-user-about-supersession-threat
4043 being called in insert_from_buffer (via in
4044 prepare_to_modify_buffer). */
4045 specbind (intern ("buffer-file-name"), Qnil
);
4046 insert_from_buffer (XBUFFER (conversion_buffer
),
4047 same_at_start_charpos
, inserted_chars
, 0);
4048 /* Set `inserted' to the number of inserted characters. */
4049 inserted
= PT
- temp
;
4050 /* Set point before the inserted characters. */
4051 SET_PT_BOTH (temp
, same_at_start
);
4053 unbind_to (this_count
, Qnil
);
4059 total
= end_offset
- beg_offset
;
4061 /* For a special file, all we can do is guess. */
4062 total
= READ_BUF_SIZE
;
4064 if (NILP (visit
) && total
> 0)
4066 if (!NILP (BVAR (current_buffer
, file_truename
))
4067 /* Make binding buffer-file-name to nil effective. */
4068 && !NILP (BVAR (current_buffer
, filename
))
4069 && SAVE_MODIFF
>= MODIFF
)
4070 we_locked_file
= true;
4071 prepare_to_modify_buffer (PT
, PT
, NULL
);
4074 move_gap_both (PT
, PT_BYTE
);
4075 if (GAP_SIZE
< total
)
4076 make_gap (total
- GAP_SIZE
);
4078 if (beg_offset
!= 0 || !NILP (replace
))
4080 if (lseek (fd
, beg_offset
, SEEK_SET
) < 0)
4081 report_file_error ("Setting file position", orig_filename
);
4084 /* In the following loop, HOW_MUCH contains the total bytes read so
4085 far for a regular file, and not changed for a special file. But,
4086 before exiting the loop, it is set to a negative value if I/O
4090 /* Total bytes inserted. */
4093 /* Here, we don't do code conversion in the loop. It is done by
4094 decode_coding_gap after all data are read into the buffer. */
4096 ptrdiff_t gap_size
= GAP_SIZE
;
4098 while (how_much
< total
)
4100 /* `try' is reserved in some compilers (Microsoft C). */
4101 ptrdiff_t trytry
= min (total
- how_much
, READ_BUF_SIZE
);
4108 /* Maybe make more room. */
4109 if (gap_size
< trytry
)
4111 make_gap (trytry
- gap_size
);
4112 gap_size
= GAP_SIZE
- inserted
;
4115 /* Read from the file, capturing `quit'. When an
4116 error occurs, end the loop, and arrange for a quit
4117 to be signaled after decoding the text we read. */
4118 nbytes
= internal_condition_case_1
4120 make_save_int_int_int (fd
, inserted
, trytry
),
4121 Qerror
, read_non_regular_quit
);
4129 this = XINT (nbytes
);
4133 /* Allow quitting out of the actual I/O. We don't make text
4134 part of the buffer until all the reading is done, so a C-g
4135 here doesn't do any harm. */
4138 this = emacs_read (fd
,
4139 ((char *) BEG_ADDR
+ PT_BYTE
- BEG_BYTE
4153 /* For a regular file, where TOTAL is the real size,
4154 count HOW_MUCH to compare with it.
4155 For a special file, where TOTAL is just a buffer size,
4156 so don't bother counting in HOW_MUCH.
4157 (INSERTED is where we count the number of characters inserted.) */
4164 /* Now we have either read all the file data into the gap,
4165 or stop reading on I/O error or quit. If nothing was
4166 read, undo marking the buffer modified. */
4171 unlock_file (BVAR (current_buffer
, file_truename
));
4172 Vdeactivate_mark
= old_Vdeactivate_mark
;
4175 Fset (Qdeactivate_mark
, Qt
);
4178 clear_unwind_protect (fd_index
);
4181 report_file_error ("Read error", orig_filename
);
4183 /* Make the text read part of the buffer. */
4184 GAP_SIZE
-= inserted
;
4186 GPT_BYTE
+= inserted
;
4188 ZV_BYTE
+= inserted
;
4193 /* Put an anchor to ensure multi-byte form ends at gap. */
4198 if (NILP (coding_system
))
4200 /* The coding system is not yet decided. Decide it by an
4201 optimized method for handling `coding:' tag.
4203 Note that we can get here only if the buffer was empty
4204 before the insertion. */
4206 if (!NILP (Vcoding_system_for_read
))
4207 coding_system
= Vcoding_system_for_read
;
4210 /* Since we are sure that the current buffer was empty
4211 before the insertion, we can toggle
4212 enable-multibyte-characters directly here without taking
4213 care of marker adjustment. By this way, we can run Lisp
4214 program safely before decoding the inserted text. */
4215 Lisp_Object unwind_data
;
4216 ptrdiff_t count1
= SPECPDL_INDEX ();
4218 unwind_data
= Fcons (BVAR (current_buffer
, enable_multibyte_characters
),
4219 Fcons (BVAR (current_buffer
, undo_list
),
4220 Fcurrent_buffer ()));
4221 bset_enable_multibyte_characters (current_buffer
, Qnil
);
4222 bset_undo_list (current_buffer
, Qt
);
4223 record_unwind_protect (decide_coding_unwind
, unwind_data
);
4225 if (inserted
> 0 && ! NILP (Vset_auto_coding_function
))
4227 coding_system
= call2 (Vset_auto_coding_function
,
4228 filename
, make_number (inserted
));
4231 if (NILP (coding_system
))
4233 /* If the coding system is not yet decided, check
4234 file-coding-system-alist. */
4235 coding_system
= CALLN (Ffind_operation_coding_system
,
4236 Qinsert_file_contents
, orig_filename
,
4237 visit
, beg
, end
, Qnil
);
4238 if (CONSP (coding_system
))
4239 coding_system
= XCAR (coding_system
);
4241 unbind_to (count1
, Qnil
);
4242 inserted
= Z_BYTE
- BEG_BYTE
;
4245 if (NILP (coding_system
))
4246 coding_system
= Qundecided
;
4248 CHECK_CODING_SYSTEM (coding_system
);
4250 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
4251 /* We must suppress all character code conversion except for
4252 end-of-line conversion. */
4253 coding_system
= raw_text_coding_system (coding_system
);
4254 setup_coding_system (coding_system
, &coding
);
4255 /* Ensure we set Vlast_coding_system_used. */
4256 set_coding_system
= true;
4261 /* When we visit a file by raw-text, we change the buffer to
4263 if (CODING_FOR_UNIBYTE (&coding
)
4264 /* Can't do this if part of the buffer might be preserved. */
4267 /* Visiting a file with these coding system makes the buffer
4270 bset_enable_multibyte_characters (current_buffer
, Qnil
);
4272 Fset_buffer_multibyte (Qnil
);
4276 coding
.dst_multibyte
= ! NILP (BVAR (current_buffer
, enable_multibyte_characters
));
4277 if (CODING_MAY_REQUIRE_DECODING (&coding
)
4278 && (inserted
> 0 || CODING_REQUIRE_FLUSHING (&coding
)))
4280 move_gap_both (PT
, PT_BYTE
);
4281 GAP_SIZE
+= inserted
;
4282 ZV_BYTE
-= inserted
;
4286 decode_coding_gap (&coding
, inserted
, inserted
);
4287 inserted
= coding
.produced_char
;
4288 coding_system
= CODING_ID_NAME (coding
.id
);
4290 else if (inserted
> 0)
4292 invalidate_buffer_caches (current_buffer
, PT
, PT
+ inserted
);
4293 adjust_after_insert (PT
, PT_BYTE
, PT
+ inserted
, PT_BYTE
+ inserted
,
4297 /* Call after-change hooks for the inserted text, aside from the case
4298 of normal visiting (not with REPLACE), which is done in a new buffer
4299 "before" the buffer is changed. */
4300 if (inserted
> 0 && total
> 0
4301 && (NILP (visit
) || !NILP (replace
)))
4303 signal_after_change (PT
, 0, inserted
);
4304 update_compositions (PT
, PT
, CHECK_BORDER
);
4307 /* Now INSERTED is measured in characters. */
4312 restore_window_points (window_markers
, inserted
,
4313 BYTE_TO_CHAR (same_at_start
),
4314 same_at_end_charpos
);
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
);
4333 if (!NILP (BVAR (current_buffer
, file_truename
)))
4334 unlock_file (BVAR (current_buffer
, file_truename
));
4335 unlock_file (filename
);
4338 xsignal2 (Qfile_error
,
4339 build_string ("not a regular file"), orig_filename
);
4342 if (set_coding_system
)
4343 Vlast_coding_system_used
= coding_system
;
4345 if (! NILP (Ffboundp (Qafter_insert_file_set_coding
)))
4347 insval
= call2 (Qafter_insert_file_set_coding
, make_number (inserted
),
4349 if (! NILP (insval
))
4351 if (! RANGED_INTEGERP (0, insval
, ZV
- PT
))
4352 wrong_type_argument (intern ("inserted-chars"), insval
);
4353 inserted
= XFASTINT (insval
);
4357 /* Decode file format. */
4360 /* Don't run point motion or modification hooks when decoding. */
4361 ptrdiff_t count1
= SPECPDL_INDEX ();
4362 ptrdiff_t old_inserted
= inserted
;
4363 specbind (Qinhibit_point_motion_hooks
, Qt
);
4364 specbind (Qinhibit_modification_hooks
, Qt
);
4366 /* Save old undo list and don't record undo for decoding. */
4367 old_undo
= BVAR (current_buffer
, undo_list
);
4368 bset_undo_list (current_buffer
, Qt
);
4372 insval
= call3 (Qformat_decode
,
4373 Qnil
, make_number (inserted
), visit
);
4374 if (! RANGED_INTEGERP (0, insval
, ZV
- PT
))
4375 wrong_type_argument (intern ("inserted-chars"), insval
);
4376 inserted
= XFASTINT (insval
);
4380 /* If REPLACE is non-nil and we succeeded in not replacing the
4381 beginning or end of the buffer text with the file's contents,
4382 call format-decode with `point' positioned at the beginning
4383 of the buffer and `inserted' equaling the number of
4384 characters in the buffer. Otherwise, format-decode might
4385 fail to correctly analyze the beginning or end of the buffer.
4386 Hence we temporarily save `point' and `inserted' here and
4387 restore `point' iff format-decode did not insert or delete
4388 any text. Otherwise we leave `point' at point-min. */
4389 ptrdiff_t opoint
= PT
;
4390 ptrdiff_t opoint_byte
= PT_BYTE
;
4391 ptrdiff_t oinserted
= ZV
- BEGV
;
4392 EMACS_INT ochars_modiff
= CHARS_MODIFF
;
4394 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
4395 insval
= call3 (Qformat_decode
,
4396 Qnil
, make_number (oinserted
), visit
);
4397 if (! RANGED_INTEGERP (0, insval
, ZV
- PT
))
4398 wrong_type_argument (intern ("inserted-chars"), insval
);
4399 if (ochars_modiff
== CHARS_MODIFF
)
4400 /* format_decode didn't modify buffer's characters => move
4401 point back to position before inserted text and leave
4402 value of inserted alone. */
4403 SET_PT_BOTH (opoint
, opoint_byte
);
4405 /* format_decode modified buffer's characters => consider
4406 entire buffer changed and leave point at point-min. */
4407 inserted
= XFASTINT (insval
);
4410 /* For consistency with format-decode call these now iff inserted > 0
4411 (martin 2007-06-28). */
4412 p
= Vafter_insert_file_functions
;
4417 insval
= call1 (XCAR (p
), make_number (inserted
));
4420 if (! RANGED_INTEGERP (0, insval
, ZV
- PT
))
4421 wrong_type_argument (intern ("inserted-chars"), insval
);
4422 inserted
= XFASTINT (insval
);
4427 /* For the rationale of this see the comment on
4428 format-decode above. */
4429 ptrdiff_t opoint
= PT
;
4430 ptrdiff_t opoint_byte
= PT_BYTE
;
4431 ptrdiff_t oinserted
= ZV
- BEGV
;
4432 EMACS_INT ochars_modiff
= CHARS_MODIFF
;
4434 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
4435 insval
= call1 (XCAR (p
), make_number (oinserted
));
4438 if (! RANGED_INTEGERP (0, insval
, ZV
- PT
))
4439 wrong_type_argument (intern ("inserted-chars"), insval
);
4440 if (ochars_modiff
== CHARS_MODIFF
)
4441 /* after_insert_file_functions didn't modify
4442 buffer's characters => move point back to
4443 position before inserted text and leave value of
4445 SET_PT_BOTH (opoint
, opoint_byte
);
4447 /* after_insert_file_functions did modify buffer's
4448 characters => consider entire buffer changed and
4449 leave point at point-min. */
4450 inserted
= XFASTINT (insval
);
4458 if (!empty_undo_list_p
)
4460 bset_undo_list (current_buffer
, old_undo
);
4461 if (CONSP (old_undo
) && inserted
!= old_inserted
)
4463 /* Adjust the last undo record for the size change during
4464 the format conversion. */
4465 Lisp_Object tem
= XCAR (old_undo
);
4466 if (CONSP (tem
) && INTEGERP (XCAR (tem
))
4467 && INTEGERP (XCDR (tem
))
4468 && XFASTINT (XCDR (tem
)) == PT
+ old_inserted
)
4469 XSETCDR (tem
, make_number (PT
+ inserted
));
4473 /* If undo_list was Qt before, keep it that way.
4474 Otherwise start with an empty undo_list. */
4475 bset_undo_list (current_buffer
, EQ (old_undo
, Qt
) ? Qt
: Qnil
);
4477 unbind_to (count1
, Qnil
);
4481 && current_buffer
->modtime
.tv_nsec
== NONEXISTENT_MODTIME_NSECS
)
4483 /* If visiting nonexistent file, return nil. */
4484 report_file_errno ("Opening input file", orig_filename
, save_errno
);
4487 /* We made a lot of deletions and insertions above, so invalidate
4488 the newline cache for the entire region of the inserted
4490 if (current_buffer
->base_buffer
&& current_buffer
->base_buffer
->newline_cache
)
4491 invalidate_region_cache (current_buffer
->base_buffer
,
4492 current_buffer
->base_buffer
->newline_cache
,
4493 PT
- BEG
, Z
- PT
- inserted
);
4494 else if (current_buffer
->newline_cache
)
4495 invalidate_region_cache (current_buffer
,
4496 current_buffer
->newline_cache
,
4497 PT
- BEG
, Z
- PT
- inserted
);
4500 Fsignal (Qquit
, Qnil
);
4502 /* Retval needs to be dealt with in all cases consistently. */
4504 val
= list2 (orig_filename
, make_number (inserted
));
4506 return unbind_to (count
, val
);
4509 static Lisp_Object
build_annotations (Lisp_Object
, Lisp_Object
);
4512 build_annotations_unwind (Lisp_Object arg
)
4514 Vwrite_region_annotation_buffers
= arg
;
4517 /* Decide the coding-system to encode the data with. */
4520 choose_write_coding_system (Lisp_Object start
, Lisp_Object end
, Lisp_Object filename
,
4521 Lisp_Object append
, Lisp_Object visit
, Lisp_Object lockname
,
4522 struct coding_system
*coding
)
4525 Lisp_Object eol_parent
= Qnil
;
4528 && NILP (Fstring_equal (BVAR (current_buffer
, filename
),
4529 BVAR (current_buffer
, auto_save_file_name
))))
4534 else if (!NILP (Vcoding_system_for_write
))
4536 val
= Vcoding_system_for_write
;
4537 if (coding_system_require_warning
4538 && !NILP (Ffboundp (Vselect_safe_coding_system_function
)))
4539 /* Confirm that VAL can surely encode the current region. */
4540 val
= call5 (Vselect_safe_coding_system_function
,
4541 start
, end
, list2 (Qt
, val
),
4546 /* If the variable `buffer-file-coding-system' is set locally,
4547 it means that the file was read with some kind of code
4548 conversion or the variable is explicitly set by users. We
4549 had better write it out with the same coding system even if
4550 `enable-multibyte-characters' is nil.
4552 If it is not set locally, we anyway have to convert EOL
4553 format if the default value of `buffer-file-coding-system'
4554 tells that it is not Unix-like (LF only) format. */
4555 bool using_default_coding
= 0;
4556 bool force_raw_text
= 0;
4558 val
= BVAR (current_buffer
, buffer_file_coding_system
);
4560 || NILP (Flocal_variable_p (Qbuffer_file_coding_system
, Qnil
)))
4563 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
4569 /* Check file-coding-system-alist. */
4570 Lisp_Object coding_systems
4571 = CALLN (Ffind_operation_coding_system
, Qwrite_region
, start
, end
,
4572 filename
, append
, visit
, lockname
);
4573 if (CONSP (coding_systems
) && !NILP (XCDR (coding_systems
)))
4574 val
= XCDR (coding_systems
);
4579 /* If we still have not decided a coding system, use the
4580 current buffer's value of buffer-file-coding-system. */
4581 val
= BVAR (current_buffer
, buffer_file_coding_system
);
4582 using_default_coding
= 1;
4585 if (! NILP (val
) && ! force_raw_text
)
4587 Lisp_Object spec
, attrs
;
4589 CHECK_CODING_SYSTEM (val
);
4590 CHECK_CODING_SYSTEM_GET_SPEC (val
, spec
);
4591 attrs
= AREF (spec
, 0);
4592 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
4597 && !NILP (Ffboundp (Vselect_safe_coding_system_function
)))
4599 /* Confirm that VAL can surely encode the current region. */
4600 val
= call5 (Vselect_safe_coding_system_function
,
4601 start
, end
, val
, Qnil
, filename
);
4602 /* As the function specified by select-safe-coding-system-function
4603 is out of our control, make sure we are not fed by bogus
4606 CHECK_CODING_SYSTEM (val
);
4609 /* If the decided coding-system doesn't specify end-of-line
4610 format, we use that of
4611 `default-buffer-file-coding-system'. */
4612 if (! using_default_coding
)
4614 Lisp_Object dflt
= BVAR (&buffer_defaults
, buffer_file_coding_system
);
4617 val
= coding_inherit_eol_type (val
, dflt
);
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
);
4627 setup_coding_system (val
, coding
);
4629 if (!STRINGP (start
) && !NILP (BVAR (current_buffer
, selective_display
)))
4630 coding
->mode
|= CODING_MODE_SELECTIVE_DISPLAY
;
4634 DEFUN ("write-region", Fwrite_region
, Swrite_region
, 3, 7,
4635 "r\nFWrite region to file: \ni\ni\ni\np",
4636 doc
: /* Write current region into specified file.
4637 When called from a program, requires three arguments:
4638 START, END and FILENAME. START and END are normally buffer positions
4639 specifying the part of the buffer to write.
4640 If START is nil, that means to use the entire buffer contents.
4641 If START is a string, then output that string to the file
4642 instead of any buffer contents; END is ignored.
4644 Optional fourth argument APPEND if non-nil means
4645 append to existing file contents (if any). If it is a number,
4646 seek to that offset in the file before writing.
4647 Optional fifth argument VISIT, if t or a string, means
4648 set the last-save-file-modtime of buffer to this file's modtime
4649 and mark buffer not modified.
4650 If VISIT is a string, it is a second file name;
4651 the output goes to FILENAME, but the buffer is marked as visiting VISIT.
4652 VISIT is also the file name to lock and unlock for clash detection.
4653 If VISIT is neither t nor nil nor a string, or if Emacs is in batch mode,
4654 do not display the \"Wrote file\" message.
4655 The optional sixth arg LOCKNAME, if non-nil, specifies the name to
4656 use for locking and unlocking, overriding FILENAME and VISIT.
4657 The optional seventh arg MUSTBENEW, if non-nil, insists on a check
4658 for an existing file with the same name. If MUSTBENEW is `excl',
4659 that means to get an error if the file already exists; never overwrite.
4660 If MUSTBENEW is neither nil nor `excl', that means ask for
4661 confirmation before overwriting, but do go ahead and overwrite the file
4662 if the user confirms.
4664 This does code conversion according to the value of
4665 `coding-system-for-write', `buffer-file-coding-system', or
4666 `file-coding-system-alist', and sets the variable
4667 `last-coding-system-used' to the coding system actually used.
4669 This calls `write-region-annotate-functions' at the start, and
4670 `write-region-post-annotation-function' at the end. */)
4671 (Lisp_Object start
, Lisp_Object end
, Lisp_Object filename
, Lisp_Object append
,
4672 Lisp_Object visit
, Lisp_Object lockname
, Lisp_Object mustbenew
)
4674 return write_region (start
, end
, filename
, append
, visit
, lockname
, mustbenew
,
4678 /* Like Fwrite_region, except that if DESC is nonnegative, it is a file
4679 descriptor for FILENAME, so do not open or close FILENAME. */
4682 write_region (Lisp_Object start
, Lisp_Object end
, Lisp_Object filename
,
4683 Lisp_Object append
, Lisp_Object visit
, Lisp_Object lockname
,
4684 Lisp_Object mustbenew
, int desc
)
4688 off_t offset UNINIT
;
4689 bool open_and_close_file
= desc
< 0;
4694 struct timespec modtime
;
4695 ptrdiff_t count
= SPECPDL_INDEX ();
4696 ptrdiff_t count1 UNINIT
;
4697 Lisp_Object handler
;
4698 Lisp_Object visit_file
;
4699 Lisp_Object annotations
;
4700 Lisp_Object encoded_filename
;
4701 bool visiting
= (EQ (visit
, Qt
) || STRINGP (visit
));
4702 bool quietly
= !NILP (visit
);
4703 bool file_locked
= 0;
4704 struct buffer
*given_buffer
;
4705 struct coding_system coding
;
4707 if (current_buffer
->base_buffer
&& visiting
)
4708 error ("Cannot do file visiting in an indirect buffer");
4710 if (!NILP (start
) && !STRINGP (start
))
4711 validate_region (&start
, &end
);
4715 filename
= Fexpand_file_name (filename
, Qnil
);
4717 if (!NILP (mustbenew
) && !EQ (mustbenew
, Qexcl
))
4718 barf_or_query_if_file_exists (filename
, false, "overwrite", true, true);
4720 if (STRINGP (visit
))
4721 visit_file
= Fexpand_file_name (visit
, Qnil
);
4723 visit_file
= filename
;
4725 if (NILP (lockname
))
4726 lockname
= visit_file
;
4730 /* If the file name has special constructs in it,
4731 call the corresponding file handler. */
4732 handler
= Ffind_file_name_handler (filename
, Qwrite_region
);
4733 /* If FILENAME has no handler, see if VISIT has one. */
4734 if (NILP (handler
) && STRINGP (visit
))
4735 handler
= Ffind_file_name_handler (visit
, Qwrite_region
);
4737 if (!NILP (handler
))
4740 val
= call6 (handler
, Qwrite_region
, start
, end
,
4741 filename
, append
, visit
);
4745 SAVE_MODIFF
= MODIFF
;
4746 XSETFASTINT (BVAR (current_buffer
, save_length
), Z
- BEG
);
4747 bset_filename (current_buffer
, visit_file
);
4753 record_unwind_protect (save_restriction_restore
, save_restriction_save ());
4755 /* Special kludge to simplify auto-saving. */
4758 /* Do it later, so write-region-annotate-function can work differently
4759 if we save "the buffer" vs "a region".
4760 This is useful in tar-mode. --Stef
4761 XSETFASTINT (start, BEG);
4762 XSETFASTINT (end, Z); */
4766 record_unwind_protect (build_annotations_unwind
,
4767 Vwrite_region_annotation_buffers
);
4768 Vwrite_region_annotation_buffers
= list1 (Fcurrent_buffer ());
4770 given_buffer
= current_buffer
;
4772 if (!STRINGP (start
))
4774 annotations
= build_annotations (start
, end
);
4776 if (current_buffer
!= given_buffer
)
4778 XSETFASTINT (start
, BEGV
);
4779 XSETFASTINT (end
, ZV
);
4785 XSETFASTINT (start
, BEGV
);
4786 XSETFASTINT (end
, ZV
);
4789 /* Decide the coding-system to encode the data with.
4790 We used to make this choice before calling build_annotations, but that
4791 leads to problems when a write-annotate-function takes care of
4792 unsavable chars (as was the case with X-Symbol). */
4793 Vlast_coding_system_used
4794 = choose_write_coding_system (start
, end
, filename
,
4795 append
, visit
, lockname
, &coding
);
4797 if (open_and_close_file
&& !auto_saving
)
4799 lock_file (lockname
);
4803 encoded_filename
= ENCODE_FILE (filename
);
4804 fn
= SSDATA (encoded_filename
);
4805 open_flags
= O_WRONLY
| O_CREAT
;
4806 open_flags
|= EQ (mustbenew
, Qexcl
) ? O_EXCL
: !NILP (append
) ? 0 : O_TRUNC
;
4807 if (NUMBERP (append
))
4808 offset
= file_offset (append
);
4809 else if (!NILP (append
))
4810 open_flags
|= O_APPEND
;
4812 mode
= S_IREAD
| S_IWRITE
;
4814 mode
= auto_saving
? auto_save_mode_bits
: 0666;
4817 if (open_and_close_file
)
4819 desc
= emacs_open (fn
, open_flags
, mode
);
4822 int open_errno
= errno
;
4824 unlock_file (lockname
);
4825 report_file_errno ("Opening output file", filename
, open_errno
);
4828 count1
= SPECPDL_INDEX ();
4829 record_unwind_protect_int (close_file_unwind
, desc
);
4832 if (NUMBERP (append
))
4834 off_t ret
= lseek (desc
, offset
, SEEK_SET
);
4837 int lseek_errno
= errno
;
4839 unlock_file (lockname
);
4840 report_file_errno ("Lseek error", filename
, lseek_errno
);
4846 if (STRINGP (start
))
4847 ok
= a_write (desc
, start
, 0, SCHARS (start
), &annotations
, &coding
);
4848 else if (XINT (start
) != XINT (end
))
4849 ok
= a_write (desc
, Qnil
, XINT (start
), XINT (end
) - XINT (start
),
4850 &annotations
, &coding
);
4853 /* If file was empty, still need to write the annotations. */
4854 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
4855 ok
= a_write (desc
, Qnil
, XINT (end
), 0, &annotations
, &coding
);
4859 if (ok
&& CODING_REQUIRE_FLUSHING (&coding
)
4860 && !(coding
.mode
& CODING_MODE_LAST_BLOCK
))
4862 /* We have to flush out a data. */
4863 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
4864 ok
= e_write (desc
, Qnil
, 1, 1, &coding
);
4870 /* fsync is not crucial for temporary files. Nor for auto-save
4871 files, since they might lose some work anyway. */
4872 if (open_and_close_file
&& !auto_saving
&& !write_region_inhibit_fsync
)
4874 /* Transfer data and metadata to disk, retrying if interrupted.
4875 fsync can report a write failure here, e.g., due to disk full
4876 under NFS. But ignore EINVAL, which means fsync is not
4877 supported on this file. */
4878 while (fsync (desc
) != 0)
4881 if (errno
!= EINVAL
)
4882 ok
= 0, save_errno
= errno
;
4887 modtime
= invalid_timespec ();
4890 if (fstat (desc
, &st
) == 0)
4891 modtime
= get_stat_mtime (&st
);
4893 ok
= 0, save_errno
= errno
;
4896 if (open_and_close_file
)
4898 /* NFS can report a write failure now. */
4899 if (emacs_close (desc
) < 0)
4900 ok
= 0, save_errno
= errno
;
4902 /* Discard the unwind protect for close_file_unwind. */
4903 specpdl_ptr
= specpdl
+ count1
;
4906 /* Some file systems have a bug where st_mtime is not updated
4907 properly after a write. For example, CIFS might not see the
4908 st_mtime change until after the file is opened again.
4910 Attempt to detect this file system bug, and update MODTIME to the
4911 newer st_mtime if the bug appears to be present. This introduces
4912 a race condition, so to avoid most instances of the race condition
4913 on non-buggy file systems, skip this check if the most recently
4914 encountered non-buggy file system was the current file system.
4916 A race condition can occur if some other process modifies the
4917 file between the fstat above and the fstat below, but the race is
4918 unlikely and a similar race between the last write and the fstat
4919 above cannot possibly be closed anyway. */
4921 if (timespec_valid_p (modtime
)
4922 && ! (valid_timestamp_file_system
&& st
.st_dev
== timestamp_file_system
))
4924 int desc1
= emacs_open (fn
, O_WRONLY
, 0);
4928 if (fstat (desc1
, &st1
) == 0
4929 && st
.st_dev
== st1
.st_dev
&& st
.st_ino
== st1
.st_ino
)
4931 /* Use the heuristic if it appears to be valid. With neither
4932 O_EXCL nor O_TRUNC, if Emacs happened to write nothing to the
4933 file, the time stamp won't change. Also, some non-POSIX
4934 systems don't update an empty file's time stamp when
4935 truncating it. Finally, file systems with 100 ns or worse
4936 resolution sometimes seem to have bugs: on a system with ns
4937 resolution, checking ns % 100 incorrectly avoids the heuristic
4938 1% of the time, but the problem should be temporary as we will
4939 try again on the next time stamp. */
4941 = ((open_flags
& (O_EXCL
| O_TRUNC
)) != 0
4943 && modtime
.tv_nsec
% 100 != 0);
4945 struct timespec modtime1
= get_stat_mtime (&st1
);
4947 && timespec_cmp (modtime
, modtime1
) == 0
4948 && st
.st_size
== st1
.st_size
)
4950 timestamp_file_system
= st
.st_dev
;
4951 valid_timestamp_file_system
= 1;
4955 st
.st_size
= st1
.st_size
;
4959 emacs_close (desc1
);
4963 /* Call write-region-post-annotation-function. */
4964 while (CONSP (Vwrite_region_annotation_buffers
))
4966 Lisp_Object buf
= XCAR (Vwrite_region_annotation_buffers
);
4967 if (!NILP (Fbuffer_live_p (buf
)))
4970 if (FUNCTIONP (Vwrite_region_post_annotation_function
))
4971 call0 (Vwrite_region_post_annotation_function
);
4973 Vwrite_region_annotation_buffers
4974 = XCDR (Vwrite_region_annotation_buffers
);
4977 unbind_to (count
, Qnil
);
4980 unlock_file (lockname
);
4982 /* Do this before reporting IO error
4983 to avoid a "file has changed on disk" warning on
4984 next attempt to save. */
4985 if (timespec_valid_p (modtime
))
4987 current_buffer
->modtime
= modtime
;
4988 current_buffer
->modtime_size
= st
.st_size
;
4992 report_file_errno ("Write error", filename
, save_errno
);
4996 SAVE_MODIFF
= MODIFF
;
4997 XSETFASTINT (BVAR (current_buffer
, save_length
), Z
- BEG
);
4998 bset_filename (current_buffer
, visit_file
);
4999 update_mode_lines
= 14;
5004 && ! NILP (Fstring_equal (BVAR (current_buffer
, filename
),
5005 BVAR (current_buffer
, auto_save_file_name
))))
5006 SAVE_MODIFF
= MODIFF
;
5011 if (!auto_saving
&& !noninteractive
)
5012 message_with_string ((NUMBERP (append
)
5022 DEFUN ("car-less-than-car", Fcar_less_than_car
, Scar_less_than_car
, 2, 2, 0,
5023 doc
: /* Return t if (car A) is numerically less than (car B). */)
5024 (Lisp_Object a
, Lisp_Object b
)
5026 return CALLN (Flss
, Fcar (a
), Fcar (b
));
5029 /* Build the complete list of annotations appropriate for writing out
5030 the text between START and END, by calling all the functions in
5031 write-region-annotate-functions and merging the lists they return.
5032 If one of these functions switches to a different buffer, we assume
5033 that buffer contains altered text. Therefore, the caller must
5034 make sure to restore the current buffer in all cases,
5035 as save-excursion would do. */
5038 build_annotations (Lisp_Object start
, Lisp_Object end
)
5040 Lisp_Object annotations
;
5042 Lisp_Object original_buffer
;
5044 bool used_global
= false;
5046 XSETBUFFER (original_buffer
, current_buffer
);
5049 p
= Vwrite_region_annotate_functions
;
5052 struct buffer
*given_buffer
= current_buffer
;
5053 if (EQ (Qt
, XCAR (p
)) && !used_global
)
5054 { /* Use the global value of the hook. */
5057 Fdefault_value (Qwrite_region_annotate_functions
),
5061 Vwrite_region_annotations_so_far
= annotations
;
5062 res
= call2 (XCAR (p
), start
, end
);
5063 /* If the function makes a different buffer current,
5064 assume that means this buffer contains altered text to be output.
5065 Reset START and END from the buffer bounds
5066 and discard all previous annotations because they should have
5067 been dealt with by this function. */
5068 if (current_buffer
!= given_buffer
)
5070 Vwrite_region_annotation_buffers
5071 = Fcons (Fcurrent_buffer (),
5072 Vwrite_region_annotation_buffers
);
5073 XSETFASTINT (start
, BEGV
);
5074 XSETFASTINT (end
, ZV
);
5077 Flength (res
); /* Check basic validity of return value */
5078 annotations
= merge (annotations
, res
, Qcar_less_than_car
);
5082 /* Now do the same for annotation functions implied by the file-format */
5083 if (auto_saving
&& (!EQ (BVAR (current_buffer
, auto_save_file_format
), Qt
)))
5084 p
= BVAR (current_buffer
, auto_save_file_format
);
5086 p
= BVAR (current_buffer
, file_format
);
5087 for (i
= 0; CONSP (p
); p
= XCDR (p
), ++i
)
5089 struct buffer
*given_buffer
= current_buffer
;
5091 Vwrite_region_annotations_so_far
= annotations
;
5093 /* Value is either a list of annotations or nil if the function
5094 has written annotations to a temporary buffer, which is now
5096 res
= call5 (Qformat_annotate_function
, XCAR (p
), start
, end
,
5097 original_buffer
, make_number (i
));
5098 if (current_buffer
!= given_buffer
)
5100 XSETFASTINT (start
, BEGV
);
5101 XSETFASTINT (end
, ZV
);
5106 annotations
= merge (annotations
, res
, Qcar_less_than_car
);
5113 /* Write to descriptor DESC the NCHARS chars starting at POS of STRING.
5114 If STRING is nil, POS is the character position in the current buffer.
5115 Intersperse with them the annotations from *ANNOT
5116 which fall within the range of POS to POS + NCHARS,
5117 each at its appropriate position.
5119 We modify *ANNOT by discarding elements as we use them up.
5121 Return true if successful. */
5124 a_write (int desc
, Lisp_Object string
, ptrdiff_t pos
,
5125 ptrdiff_t nchars
, Lisp_Object
*annot
,
5126 struct coding_system
*coding
)
5130 ptrdiff_t lastpos
= pos
+ nchars
;
5132 while (NILP (*annot
) || CONSP (*annot
))
5134 tem
= Fcar_safe (Fcar (*annot
));
5137 nextpos
= XFASTINT (tem
);
5139 /* If there are no more annotations in this range,
5140 output the rest of the range all at once. */
5141 if (! (nextpos
>= pos
&& nextpos
<= lastpos
))
5142 return e_write (desc
, string
, pos
, lastpos
, coding
);
5144 /* Output buffer text up to the next annotation's position. */
5147 if (!e_write (desc
, string
, pos
, nextpos
, coding
))
5151 /* Output the annotation. */
5152 tem
= Fcdr (Fcar (*annot
));
5155 if (!e_write (desc
, tem
, 0, SCHARS (tem
), coding
))
5158 *annot
= Fcdr (*annot
);
5163 /* Maximum number of characters that the next
5164 function encodes per one loop iteration. */
5166 enum { E_WRITE_MAX
= 8 * 1024 * 1024 };
5168 /* Write text in the range START and END into descriptor DESC,
5169 encoding them with coding system CODING. If STRING is nil, START
5170 and END are character positions of the current buffer, else they
5171 are indexes to the string STRING. Return true if successful. */
5174 e_write (int desc
, Lisp_Object string
, ptrdiff_t start
, ptrdiff_t end
,
5175 struct coding_system
*coding
)
5177 if (STRINGP (string
))
5180 end
= SCHARS (string
);
5183 /* We used to have a code for handling selective display here. But,
5184 now it is handled within encode_coding. */
5188 if (STRINGP (string
))
5190 coding
->src_multibyte
= SCHARS (string
) < SBYTES (string
);
5191 if (CODING_REQUIRE_ENCODING (coding
))
5193 ptrdiff_t nchars
= min (end
- start
, E_WRITE_MAX
);
5195 /* Avoid creating huge Lisp string in encode_coding_object. */
5196 if (nchars
== E_WRITE_MAX
)
5197 coding
->raw_destination
= 1;
5199 encode_coding_object
5200 (coding
, string
, start
, string_char_to_byte (string
, start
),
5201 start
+ nchars
, string_char_to_byte (string
, start
+ nchars
),
5206 coding
->dst_object
= string
;
5207 coding
->consumed_char
= SCHARS (string
);
5208 coding
->produced
= SBYTES (string
);
5213 ptrdiff_t start_byte
= CHAR_TO_BYTE (start
);
5214 ptrdiff_t end_byte
= CHAR_TO_BYTE (end
);
5216 coding
->src_multibyte
= (end
- start
) < (end_byte
- start_byte
);
5217 if (CODING_REQUIRE_ENCODING (coding
))
5219 ptrdiff_t nchars
= min (end
- start
, E_WRITE_MAX
);
5222 if (nchars
== E_WRITE_MAX
)
5223 coding
->raw_destination
= 1;
5225 encode_coding_object
5226 (coding
, Fcurrent_buffer (), start
, start_byte
,
5227 start
+ nchars
, CHAR_TO_BYTE (start
+ nchars
), Qt
);
5231 coding
->dst_object
= Qnil
;
5232 coding
->dst_pos_byte
= start_byte
;
5233 if (start
>= GPT
|| end
<= GPT
)
5235 coding
->consumed_char
= end
- start
;
5236 coding
->produced
= end_byte
- start_byte
;
5240 coding
->consumed_char
= GPT
- start
;
5241 coding
->produced
= GPT_BYTE
- start_byte
;
5246 if (coding
->produced
> 0)
5248 char *buf
= (coding
->raw_destination
? (char *) coding
->destination
5249 : (STRINGP (coding
->dst_object
)
5250 ? SSDATA (coding
->dst_object
)
5251 : (char *) BYTE_POS_ADDR (coding
->dst_pos_byte
)));
5252 coding
->produced
-= emacs_write_sig (desc
, buf
, coding
->produced
);
5254 if (coding
->raw_destination
)
5256 /* We're responsible for freeing this, see
5257 encode_coding_object to check why. */
5258 xfree (coding
->destination
);
5259 coding
->raw_destination
= 0;
5261 if (coding
->produced
)
5264 start
+= coding
->consumed_char
;
5270 DEFUN ("verify-visited-file-modtime", Fverify_visited_file_modtime
,
5271 Sverify_visited_file_modtime
, 0, 1, 0,
5272 doc
: /* Return t if last mod time of BUF's visited file matches what BUF records.
5273 This means that the file has not been changed since it was visited or saved.
5274 If BUF is omitted or nil, it defaults to the current buffer.
5275 See Info node `(elisp)Modification Time' for more details. */)
5278 struct buffer
*b
= decode_buffer (buf
);
5280 Lisp_Object handler
;
5281 Lisp_Object filename
;
5282 struct timespec mtime
;
5284 if (!STRINGP (BVAR (b
, filename
))) return Qt
;
5285 if (b
->modtime
.tv_nsec
== UNKNOWN_MODTIME_NSECS
) return Qt
;
5287 /* If the file name has special constructs in it,
5288 call the corresponding file handler. */
5289 handler
= Ffind_file_name_handler (BVAR (b
, filename
),
5290 Qverify_visited_file_modtime
);
5291 if (!NILP (handler
))
5292 return call2 (handler
, Qverify_visited_file_modtime
, buf
);
5294 filename
= ENCODE_FILE (BVAR (b
, filename
));
5296 mtime
= (stat (SSDATA (filename
), &st
) == 0
5297 ? get_stat_mtime (&st
)
5298 : time_error_value (errno
));
5299 if (timespec_cmp (mtime
, b
->modtime
) == 0
5300 && (b
->modtime_size
< 0
5301 || st
.st_size
== b
->modtime_size
))
5306 DEFUN ("visited-file-modtime", Fvisited_file_modtime
,
5307 Svisited_file_modtime
, 0, 0, 0,
5308 doc
: /* Return the current buffer's recorded visited file modification time.
5309 The value is a list of the form (HIGH LOW USEC PSEC), like the time values that
5310 `file-attributes' returns. If the current buffer has no recorded file
5311 modification time, this function returns 0. If the visited file
5312 doesn't exist, return -1.
5313 See Info node `(elisp)Modification Time' for more details. */)
5316 int ns
= current_buffer
->modtime
.tv_nsec
;
5318 return make_number (UNKNOWN_MODTIME_NSECS
- ns
);
5319 return make_lisp_time (current_buffer
->modtime
);
5322 DEFUN ("set-visited-file-modtime", Fset_visited_file_modtime
,
5323 Sset_visited_file_modtime
, 0, 1, 0,
5324 doc
: /* Update buffer's recorded modification time from the visited file's time.
5325 Useful if the buffer was not read from the file normally
5326 or if the file itself has been changed for some known benign reason.
5327 An argument specifies the modification time value to use
5328 \(instead of that of the visited file), in the form of a list
5329 \(HIGH LOW USEC PSEC) or an integer flag as returned by
5330 `visited-file-modtime'. */)
5331 (Lisp_Object time_flag
)
5333 if (!NILP (time_flag
))
5335 struct timespec mtime
;
5336 if (INTEGERP (time_flag
))
5338 CHECK_RANGED_INTEGER (time_flag
, -1, 0);
5339 mtime
= make_timespec (0, UNKNOWN_MODTIME_NSECS
- XINT (time_flag
));
5342 mtime
= lisp_time_argument (time_flag
);
5344 current_buffer
->modtime
= mtime
;
5345 current_buffer
->modtime_size
= -1;
5349 register Lisp_Object filename
;
5351 Lisp_Object handler
;
5353 filename
= Fexpand_file_name (BVAR (current_buffer
, filename
), Qnil
);
5355 /* If the file name has special constructs in it,
5356 call the corresponding file handler. */
5357 handler
= Ffind_file_name_handler (filename
, Qset_visited_file_modtime
);
5358 if (!NILP (handler
))
5359 /* The handler can find the file name the same way we did. */
5360 return call2 (handler
, Qset_visited_file_modtime
, Qnil
);
5362 filename
= ENCODE_FILE (filename
);
5364 if (stat (SSDATA (filename
), &st
) >= 0)
5366 current_buffer
->modtime
= get_stat_mtime (&st
);
5367 current_buffer
->modtime_size
= st
.st_size
;
5375 auto_save_error (Lisp_Object error_val
)
5377 auto_save_error_occurred
= 1;
5379 ring_bell (XFRAME (selected_frame
));
5381 AUTO_STRING (format
, "Auto-saving %s: %s");
5382 Lisp_Object msg
= CALLN (Fformat
, format
, BVAR (current_buffer
, name
),
5383 Ferror_message_string (error_val
));
5384 call3 (intern ("display-warning"),
5385 intern ("auto-save"), msg
, intern ("error"));
5396 auto_save_mode_bits
= 0666;
5398 /* Get visited file's mode to become the auto save file's mode. */
5399 if (! NILP (BVAR (current_buffer
, filename
)))
5401 if (stat (SSDATA (BVAR (current_buffer
, filename
)), &st
) >= 0)
5402 /* But make sure we can overwrite it later! */
5403 auto_save_mode_bits
= (st
.st_mode
| 0600) & 0777;
5404 else if (modes
= Ffile_modes (BVAR (current_buffer
, filename
)),
5406 /* Remote files don't cooperate with stat. */
5407 auto_save_mode_bits
= (XINT (modes
) | 0600) & 0777;
5411 Fwrite_region (Qnil
, Qnil
, BVAR (current_buffer
, auto_save_file_name
), Qnil
,
5412 NILP (Vauto_save_visited_file_name
) ? Qlambda
: Qt
,
5416 struct auto_save_unwind
5423 do_auto_save_unwind (void *arg
)
5425 struct auto_save_unwind
*p
= arg
;
5426 FILE *stream
= p
->stream
;
5427 minibuffer_auto_raise
= p
->auto_raise
;
5438 do_auto_save_make_dir (Lisp_Object dir
)
5442 auto_saving_dir_umask
= 077;
5443 result
= call2 (Qmake_directory
, dir
, Qt
);
5444 auto_saving_dir_umask
= 0;
5449 do_auto_save_eh (Lisp_Object ignore
)
5451 auto_saving_dir_umask
= 0;
5455 DEFUN ("do-auto-save", Fdo_auto_save
, Sdo_auto_save
, 0, 2, "",
5456 doc
: /* Auto-save all buffers that need it.
5457 This is all buffers that have auto-saving enabled
5458 and are changed since last auto-saved.
5459 Auto-saving writes the buffer into a file
5460 so that your editing is not lost if the system crashes.
5461 This file is not the file you visited; that changes only when you save.
5462 Normally we run the normal hook `auto-save-hook' before saving.
5464 A non-nil NO-MESSAGE argument means do not print any message if successful.
5465 A non-nil CURRENT-ONLY argument means save only current buffer. */)
5466 (Lisp_Object no_message
, Lisp_Object current_only
)
5468 struct buffer
*old
= current_buffer
, *b
;
5469 Lisp_Object tail
, buf
, hook
;
5470 bool auto_saved
= 0;
5471 int do_handled_files
;
5473 FILE *stream
= NULL
;
5474 ptrdiff_t count
= SPECPDL_INDEX ();
5475 bool orig_minibuffer_auto_raise
= minibuffer_auto_raise
;
5476 bool old_message_p
= 0;
5477 struct auto_save_unwind auto_save_unwind
;
5479 if (max_specpdl_size
< specpdl_size
+ 40)
5480 max_specpdl_size
= specpdl_size
+ 40;
5485 if (NILP (no_message
))
5487 old_message_p
= push_message ();
5488 record_unwind_protect_void (pop_message_unwind
);
5491 /* Ordinarily don't quit within this function,
5492 but don't make it impossible to quit (in case we get hung in I/O). */
5496 hook
= intern ("auto-save-hook");
5497 safe_run_hooks (hook
);
5499 if (STRINGP (Vauto_save_list_file_name
))
5501 Lisp_Object listfile
;
5503 listfile
= Fexpand_file_name (Vauto_save_list_file_name
, Qnil
);
5505 /* Don't try to create the directory when shutting down Emacs,
5506 because creating the directory might signal an error, and
5507 that would leave Emacs in a strange state. */
5508 if (!NILP (Vrun_hooks
))
5511 dir
= Ffile_name_directory (listfile
);
5512 if (NILP (Ffile_directory_p (dir
)))
5513 internal_condition_case_1 (do_auto_save_make_dir
,
5518 stream
= emacs_fopen (SSDATA (listfile
), "w");
5521 auto_save_unwind
.stream
= stream
;
5522 auto_save_unwind
.auto_raise
= minibuffer_auto_raise
;
5523 record_unwind_protect_ptr (do_auto_save_unwind
, &auto_save_unwind
);
5524 minibuffer_auto_raise
= 0;
5526 auto_save_error_occurred
= 0;
5528 /* On first pass, save all files that don't have handlers.
5529 On second pass, save all files that do have handlers.
5531 If Emacs is crashing, the handlers may tweak what is causing
5532 Emacs to crash in the first place, and it would be a shame if
5533 Emacs failed to autosave perfectly ordinary files because it
5534 couldn't handle some ange-ftp'd file. */
5536 for (do_handled_files
= 0; do_handled_files
< 2; do_handled_files
++)
5537 FOR_EACH_LIVE_BUFFER (tail
, buf
)
5541 /* Record all the buffers that have auto save mode
5542 in the special file that lists them. For each of these buffers,
5543 Record visited name (if any) and auto save name. */
5544 if (STRINGP (BVAR (b
, auto_save_file_name
))
5545 && stream
!= NULL
&& do_handled_files
== 0)
5548 if (!NILP (BVAR (b
, filename
)))
5550 fwrite (SDATA (BVAR (b
, filename
)), 1,
5551 SBYTES (BVAR (b
, filename
)), stream
);
5553 putc ('\n', stream
);
5554 fwrite (SDATA (BVAR (b
, auto_save_file_name
)), 1,
5555 SBYTES (BVAR (b
, auto_save_file_name
)), stream
);
5556 putc ('\n', stream
);
5560 if (!NILP (current_only
)
5561 && b
!= current_buffer
)
5564 /* Don't auto-save indirect buffers.
5565 The base buffer takes care of it. */
5569 /* Check for auto save enabled
5570 and file changed since last auto save
5571 and file changed since last real save. */
5572 if (STRINGP (BVAR (b
, auto_save_file_name
))
5573 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
5574 && BUF_AUTOSAVE_MODIFF (b
) < BUF_MODIFF (b
)
5575 /* -1 means we've turned off autosaving for a while--see below. */
5576 && XINT (BVAR (b
, save_length
)) >= 0
5577 && (do_handled_files
5578 || NILP (Ffind_file_name_handler (BVAR (b
, auto_save_file_name
),
5581 struct timespec before_time
= current_timespec ();
5582 struct timespec after_time
;
5584 /* If we had a failure, don't try again for 20 minutes. */
5585 if (b
->auto_save_failure_time
> 0
5586 && before_time
.tv_sec
- b
->auto_save_failure_time
< 1200)
5589 set_buffer_internal (b
);
5590 if (NILP (Vauto_save_include_big_deletions
)
5591 && (XFASTINT (BVAR (b
, save_length
)) * 10
5592 > (BUF_Z (b
) - BUF_BEG (b
)) * 13)
5593 /* A short file is likely to change a large fraction;
5594 spare the user annoying messages. */
5595 && XFASTINT (BVAR (b
, save_length
)) > 5000
5596 /* These messages are frequent and annoying for `*mail*'. */
5597 && !EQ (BVAR (b
, filename
), Qnil
)
5598 && NILP (no_message
))
5600 /* It has shrunk too much; turn off auto-saving here. */
5601 minibuffer_auto_raise
= orig_minibuffer_auto_raise
;
5602 message_with_string ("Buffer %s has shrunk a lot; auto save disabled in that buffer until next real save",
5604 minibuffer_auto_raise
= 0;
5605 /* Turn off auto-saving until there's a real save,
5606 and prevent any more warnings. */
5607 XSETINT (BVAR (b
, save_length
), -1);
5608 Fsleep_for (make_number (1), Qnil
);
5611 if (!auto_saved
&& NILP (no_message
))
5612 message1 ("Auto-saving...");
5613 internal_condition_case (auto_save_1
, Qt
, auto_save_error
);
5615 BUF_AUTOSAVE_MODIFF (b
) = BUF_MODIFF (b
);
5616 XSETFASTINT (BVAR (current_buffer
, save_length
), Z
- BEG
);
5617 set_buffer_internal (old
);
5619 after_time
= current_timespec ();
5621 /* If auto-save took more than 60 seconds,
5622 assume it was an NFS failure that got a timeout. */
5623 if (after_time
.tv_sec
- before_time
.tv_sec
> 60)
5624 b
->auto_save_failure_time
= after_time
.tv_sec
;
5628 /* Prevent another auto save till enough input events come in. */
5629 record_auto_save ();
5631 if (auto_saved
&& NILP (no_message
))
5635 /* If we are going to restore an old message,
5636 give time to read ours. */
5637 sit_for (make_number (1), 0, 0);
5640 else if (!auto_save_error_occurred
)
5641 /* Don't overwrite the error message if an error occurred.
5642 If we displayed a message and then restored a state
5643 with no message, leave a "done" message on the screen. */
5644 message1 ("Auto-saving...done");
5649 /* This restores the message-stack status. */
5650 unbind_to (count
, Qnil
);
5654 DEFUN ("set-buffer-auto-saved", Fset_buffer_auto_saved
,
5655 Sset_buffer_auto_saved
, 0, 0, 0,
5656 doc
: /* Mark current buffer as auto-saved with its current text.
5657 No auto-save file will be written until the buffer changes again. */)
5660 /* FIXME: This should not be called in indirect buffers, since
5661 they're not autosaved. */
5662 BUF_AUTOSAVE_MODIFF (current_buffer
) = MODIFF
;
5663 XSETFASTINT (BVAR (current_buffer
, save_length
), Z
- BEG
);
5664 current_buffer
->auto_save_failure_time
= 0;
5668 DEFUN ("clear-buffer-auto-save-failure", Fclear_buffer_auto_save_failure
,
5669 Sclear_buffer_auto_save_failure
, 0, 0, 0,
5670 doc
: /* Clear any record of a recent auto-save failure in the current buffer. */)
5673 current_buffer
->auto_save_failure_time
= 0;
5677 DEFUN ("recent-auto-save-p", Frecent_auto_save_p
, Srecent_auto_save_p
,
5679 doc
: /* Return t if current buffer has been auto-saved recently.
5680 More precisely, if it has been auto-saved since last read from or saved
5681 in the visited file. If the buffer has no visited file,
5682 then any auto-save counts as "recent". */)
5685 /* FIXME: maybe we should return nil for indirect buffers since
5686 they're never autosaved. */
5687 return (SAVE_MODIFF
< BUF_AUTOSAVE_MODIFF (current_buffer
) ? Qt
: Qnil
);
5690 /* Reading and completing file names. */
5692 DEFUN ("next-read-file-uses-dialog-p", Fnext_read_file_uses_dialog_p
,
5693 Snext_read_file_uses_dialog_p
, 0, 0, 0,
5694 doc
: /* Return t if a call to `read-file-name' will use a dialog.
5695 The return value is only relevant for a call to `read-file-name' that happens
5696 before any other event (mouse or keypress) is handled. */)
5699 #if (defined USE_GTK || defined USE_MOTIF \
5700 || defined HAVE_NS || defined HAVE_NTGUI)
5701 if ((NILP (last_nonmenu_event
) || CONSP (last_nonmenu_event
))
5704 && window_system_available (SELECTED_FRAME ()))
5711 DEFUN ("set-binary-mode", Fset_binary_mode
, Sset_binary_mode
, 2, 2, 0,
5712 doc
: /* Switch STREAM to binary I/O mode or text I/O mode.
5713 STREAM can be one of the symbols `stdin', `stdout', or `stderr'.
5714 If MODE is non-nil, switch STREAM to binary mode, otherwise switch
5717 As a side effect, this function flushes any pending STREAM's data.
5719 Value is the previous value of STREAM's I/O mode, nil for text mode,
5720 non-nil for binary mode.
5722 On MS-Windows and MS-DOS, binary mode is needed to read or write
5723 arbitrary binary data, and for disabling translation between CR-LF
5724 pairs and a single newline character. Examples include generation
5725 of text files with Unix-style end-of-line format using `princ' in
5726 batch mode, with standard output redirected to a file.
5728 On Posix systems, this function always returns non-nil, and has no
5729 effect except for flushing STREAM's data. */)
5730 (Lisp_Object stream
, Lisp_Object mode
)
5735 CHECK_SYMBOL (stream
);
5736 if (EQ (stream
, Qstdin
))
5738 else if (EQ (stream
, Qstdout
))
5740 else if (EQ (stream
, Qstderr
))
5743 xsignal2 (Qerror
, build_string ("unsupported stream"), stream
);
5745 binmode
= NILP (mode
) ? O_TEXT
: O_BINARY
;
5749 return (set_binary_mode (fileno (fp
), binmode
) == O_BINARY
) ? Qt
: Qnil
;
5755 realmask
= umask (0);
5758 valid_timestamp_file_system
= 0;
5760 /* fsync can be a significant performance hit. Often it doesn't
5761 suffice to make the file-save operation survive a crash. For
5762 batch scripts, which are typically part of larger shell commands
5763 that don't fsync other files, its effect on performance can be
5764 significant so its utility is particularly questionable.
5765 Hence, for now by default fsync is used only when interactive.
5767 For more on why fsync often fails to work on today's hardware, see:
5768 Zheng M et al. Understanding the robustness of SSDs under power fault.
5769 11th USENIX Conf. on File and Storage Technologies, 2013 (FAST '13), 271-84
5770 http://www.usenix.org/system/files/conference/fast13/fast13-final80.pdf
5772 For more on why fsync does not suffice even if it works properly, see:
5773 Roche X. Necessary step(s) to synchronize filename operations on disk.
5774 Austin Group Defect 672, 2013-03-19
5775 http://austingroupbugs.net/view.php?id=672 */
5776 write_region_inhibit_fsync
= noninteractive
;
5780 syms_of_fileio (void)
5782 /* Property name of a file name handler,
5783 which gives a list of operations it handles. */
5784 DEFSYM (Qoperations
, "operations");
5786 DEFSYM (Qexpand_file_name
, "expand-file-name");
5787 DEFSYM (Qsubstitute_in_file_name
, "substitute-in-file-name");
5788 DEFSYM (Qdirectory_file_name
, "directory-file-name");
5789 DEFSYM (Qfile_name_directory
, "file-name-directory");
5790 DEFSYM (Qfile_name_nondirectory
, "file-name-nondirectory");
5791 DEFSYM (Qunhandled_file_name_directory
, "unhandled-file-name-directory");
5792 DEFSYM (Qfile_name_as_directory
, "file-name-as-directory");
5793 DEFSYM (Qcopy_file
, "copy-file");
5794 DEFSYM (Qmake_directory_internal
, "make-directory-internal");
5795 DEFSYM (Qmake_directory
, "make-directory");
5796 DEFSYM (Qdelete_file
, "delete-file");
5797 DEFSYM (Qrename_file
, "rename-file");
5798 DEFSYM (Qadd_name_to_file
, "add-name-to-file");
5799 DEFSYM (Qmake_symbolic_link
, "make-symbolic-link");
5800 DEFSYM (Qfile_exists_p
, "file-exists-p");
5801 DEFSYM (Qfile_executable_p
, "file-executable-p");
5802 DEFSYM (Qfile_readable_p
, "file-readable-p");
5803 DEFSYM (Qfile_writable_p
, "file-writable-p");
5804 DEFSYM (Qfile_symlink_p
, "file-symlink-p");
5805 DEFSYM (Qaccess_file
, "access-file");
5806 DEFSYM (Qfile_directory_p
, "file-directory-p");
5807 DEFSYM (Qfile_regular_p
, "file-regular-p");
5808 DEFSYM (Qfile_accessible_directory_p
, "file-accessible-directory-p");
5809 DEFSYM (Qfile_modes
, "file-modes");
5810 DEFSYM (Qset_file_modes
, "set-file-modes");
5811 DEFSYM (Qset_file_times
, "set-file-times");
5812 DEFSYM (Qfile_selinux_context
, "file-selinux-context");
5813 DEFSYM (Qset_file_selinux_context
, "set-file-selinux-context");
5814 DEFSYM (Qfile_acl
, "file-acl");
5815 DEFSYM (Qset_file_acl
, "set-file-acl");
5816 DEFSYM (Qfile_newer_than_file_p
, "file-newer-than-file-p");
5817 DEFSYM (Qinsert_file_contents
, "insert-file-contents");
5818 DEFSYM (Qwrite_region
, "write-region");
5819 DEFSYM (Qverify_visited_file_modtime
, "verify-visited-file-modtime");
5820 DEFSYM (Qset_visited_file_modtime
, "set-visited-file-modtime");
5822 /* The symbol bound to coding-system-for-read when
5823 insert-file-contents is called for recovering a file. This is not
5824 an actual coding system name, but just an indicator to tell
5825 insert-file-contents to use `emacs-mule' with a special flag for
5826 auto saving and recovering a file. */
5827 DEFSYM (Qauto_save_coding
, "auto-save-coding");
5829 DEFSYM (Qfile_name_history
, "file-name-history");
5830 Fset (Qfile_name_history
, Qnil
);
5832 DEFSYM (Qfile_error
, "file-error");
5833 DEFSYM (Qfile_already_exists
, "file-already-exists");
5834 DEFSYM (Qfile_date_error
, "file-date-error");
5835 DEFSYM (Qfile_notify_error
, "file-notify-error");
5836 DEFSYM (Qexcl
, "excl");
5838 DEFVAR_LISP ("file-name-coding-system", Vfile_name_coding_system
,
5839 doc
: /* Coding system for encoding file names.
5840 If it is nil, `default-file-name-coding-system' (which see) is used.
5842 On MS-Windows, the value of this variable is largely ignored if
5843 `w32-unicode-filenames' (which see) is non-nil. Emacs on Windows
5844 behaves as if file names were encoded in `utf-8'. */);
5845 Vfile_name_coding_system
= Qnil
;
5847 DEFVAR_LISP ("default-file-name-coding-system",
5848 Vdefault_file_name_coding_system
,
5849 doc
: /* Default coding system for encoding file names.
5850 This variable is used only when `file-name-coding-system' is nil.
5852 This variable is set/changed by the command `set-language-environment'.
5853 User should not set this variable manually,
5854 instead use `file-name-coding-system' to get a constant encoding
5855 of file names regardless of the current language environment.
5857 On MS-Windows, the value of this variable is largely ignored if
5858 `w32-unicode-filenames' (which see) is non-nil. Emacs on Windows
5859 behaves as if file names were encoded in `utf-8'. */);
5860 Vdefault_file_name_coding_system
= Qnil
;
5862 /* Lisp functions for translating file formats. */
5863 DEFSYM (Qformat_decode
, "format-decode");
5864 DEFSYM (Qformat_annotate_function
, "format-annotate-function");
5866 /* Lisp function for setting buffer-file-coding-system and the
5867 multibyteness of the current buffer after inserting a file. */
5868 DEFSYM (Qafter_insert_file_set_coding
, "after-insert-file-set-coding");
5870 DEFSYM (Qcar_less_than_car
, "car-less-than-car");
5872 Fput (Qfile_error
, Qerror_conditions
,
5873 Fpurecopy (list2 (Qfile_error
, Qerror
)));
5874 Fput (Qfile_error
, Qerror_message
,
5875 build_pure_c_string ("File error"));
5877 Fput (Qfile_already_exists
, Qerror_conditions
,
5878 Fpurecopy (list3 (Qfile_already_exists
, Qfile_error
, Qerror
)));
5879 Fput (Qfile_already_exists
, Qerror_message
,
5880 build_pure_c_string ("File already exists"));
5882 Fput (Qfile_date_error
, Qerror_conditions
,
5883 Fpurecopy (list3 (Qfile_date_error
, Qfile_error
, Qerror
)));
5884 Fput (Qfile_date_error
, Qerror_message
,
5885 build_pure_c_string ("Cannot set file date"));
5887 Fput (Qfile_notify_error
, Qerror_conditions
,
5888 Fpurecopy (list3 (Qfile_notify_error
, Qfile_error
, Qerror
)));
5889 Fput (Qfile_notify_error
, Qerror_message
,
5890 build_pure_c_string ("File notification error"));
5892 DEFVAR_LISP ("file-name-handler-alist", Vfile_name_handler_alist
,
5893 doc
: /* Alist of elements (REGEXP . HANDLER) for file names handled specially.
5894 If a file name matches REGEXP, all I/O on that file is done by calling
5895 HANDLER. If a file name matches more than one handler, the handler
5896 whose match starts last in the file name gets precedence. The
5897 function `find-file-name-handler' checks this list for a handler for
5900 HANDLER should be a function. The first argument given to it is the
5901 name of the I/O primitive to be handled; the remaining arguments are
5902 the arguments that were passed to that primitive. For example, if you
5903 do (file-exists-p FILENAME) and FILENAME is handled by HANDLER, then
5904 HANDLER is called like this:
5906 (funcall HANDLER \\='file-exists-p FILENAME)
5908 Note that HANDLER must be able to handle all I/O primitives; if it has
5909 nothing special to do for a primitive, it should reinvoke the
5910 primitive to handle the operation \"the usual way\".
5911 See Info node `(elisp)Magic File Names' for more details. */);
5912 Vfile_name_handler_alist
= Qnil
;
5914 DEFVAR_LISP ("set-auto-coding-function",
5915 Vset_auto_coding_function
,
5916 doc
: /* If non-nil, a function to call to decide a coding system of file.
5917 Two arguments are passed to this function: the file name
5918 and the length of a file contents following the point.
5919 This function should return a coding system to decode the file contents.
5920 It should check the file name against `auto-coding-alist'.
5921 If no coding system is decided, it should check a coding system
5922 specified in the heading lines with the format:
5923 -*- ... coding: CODING-SYSTEM; ... -*-
5924 or local variable spec of the tailing lines with `coding:' tag. */);
5925 Vset_auto_coding_function
= Qnil
;
5927 DEFVAR_LISP ("after-insert-file-functions", Vafter_insert_file_functions
,
5928 doc
: /* A list of functions to be called at the end of `insert-file-contents'.
5929 Each is passed one argument, the number of characters inserted,
5930 with point at the start of the inserted text. Each function
5931 should leave point the same, and return the new character count.
5932 If `insert-file-contents' is intercepted by a handler from
5933 `file-name-handler-alist', that handler is responsible for calling the
5934 functions in `after-insert-file-functions' if appropriate. */);
5935 Vafter_insert_file_functions
= Qnil
;
5937 DEFVAR_LISP ("write-region-annotate-functions", Vwrite_region_annotate_functions
,
5938 doc
: /* A list of functions to be called at the start of `write-region'.
5939 Each is passed two arguments, START and END as for `write-region'.
5940 These are usually two numbers but not always; see the documentation
5941 for `write-region'. The function should return a list of pairs
5942 of the form (POSITION . STRING), consisting of strings to be effectively
5943 inserted at the specified positions of the file being written (1 means to
5944 insert before the first byte written). The POSITIONs must be sorted into
5947 If there are several annotation functions, the lists returned by these
5948 functions are merged destructively. As each annotation function runs,
5949 the variable `write-region-annotations-so-far' contains a list of all
5950 annotations returned by previous annotation functions.
5952 An annotation function can return with a different buffer current.
5953 Doing so removes the annotations returned by previous functions, and
5954 resets START and END to `point-min' and `point-max' of the new buffer.
5956 After `write-region' completes, Emacs calls the function stored in
5957 `write-region-post-annotation-function', once for each buffer that was
5958 current when building the annotations (i.e., at least once), with that
5959 buffer current. */);
5960 Vwrite_region_annotate_functions
= Qnil
;
5961 DEFSYM (Qwrite_region_annotate_functions
, "write-region-annotate-functions");
5963 DEFVAR_LISP ("write-region-post-annotation-function",
5964 Vwrite_region_post_annotation_function
,
5965 doc
: /* Function to call after `write-region' completes.
5966 The function is called with no arguments. If one or more of the
5967 annotation functions in `write-region-annotate-functions' changed the
5968 current buffer, the function stored in this variable is called for
5969 each of those additional buffers as well, in addition to the original
5970 buffer. The relevant buffer is current during each function call. */);
5971 Vwrite_region_post_annotation_function
= Qnil
;
5972 staticpro (&Vwrite_region_annotation_buffers
);
5974 DEFVAR_LISP ("write-region-annotations-so-far",
5975 Vwrite_region_annotations_so_far
,
5976 doc
: /* When an annotation function is called, this holds the previous annotations.
5977 These are the annotations made by other annotation functions
5978 that were already called. See also `write-region-annotate-functions'. */);
5979 Vwrite_region_annotations_so_far
= Qnil
;
5981 DEFVAR_LISP ("inhibit-file-name-handlers", Vinhibit_file_name_handlers
,
5982 doc
: /* A list of file name handlers that temporarily should not be used.
5983 This applies only to the operation `inhibit-file-name-operation'. */);
5984 Vinhibit_file_name_handlers
= Qnil
;
5986 DEFVAR_LISP ("inhibit-file-name-operation", Vinhibit_file_name_operation
,
5987 doc
: /* The operation for which `inhibit-file-name-handlers' is applicable. */);
5988 Vinhibit_file_name_operation
= Qnil
;
5990 DEFVAR_LISP ("auto-save-list-file-name", Vauto_save_list_file_name
,
5991 doc
: /* File name in which we write a list of all auto save file names.
5992 This variable is initialized automatically from `auto-save-list-file-prefix'
5993 shortly after Emacs reads your init file, if you have not yet given it
5994 a non-nil value. */);
5995 Vauto_save_list_file_name
= Qnil
;
5997 DEFVAR_LISP ("auto-save-visited-file-name", Vauto_save_visited_file_name
,
5998 doc
: /* Non-nil says auto-save a buffer in the file it is visiting, when practical.
5999 Normally auto-save files are written under other names. */);
6000 Vauto_save_visited_file_name
= Qnil
;
6002 DEFVAR_LISP ("auto-save-include-big-deletions", Vauto_save_include_big_deletions
,
6003 doc
: /* If non-nil, auto-save even if a large part of the text is deleted.
6004 If nil, deleting a substantial portion of the text disables auto-save
6005 in the buffer; this is the default behavior, because the auto-save
6006 file is usually more useful if it contains the deleted text. */);
6007 Vauto_save_include_big_deletions
= Qnil
;
6009 DEFVAR_BOOL ("write-region-inhibit-fsync", write_region_inhibit_fsync
,
6010 doc
: /* Non-nil means don't call fsync in `write-region'.
6011 This variable affects calls to `write-region' as well as save commands.
6012 Setting this to nil may avoid data loss if the system loses power or
6013 the operating system crashes. By default, it is non-nil in batch mode. */);
6014 write_region_inhibit_fsync
= 0; /* See also `init_fileio' above. */
6016 DEFVAR_BOOL ("delete-by-moving-to-trash", delete_by_moving_to_trash
,
6017 doc
: /* Specifies whether to use the system's trash can.
6018 When non-nil, certain file deletion commands use the function
6019 `move-file-to-trash' instead of deleting files outright.
6020 This includes interactive calls to `delete-file' and
6021 `delete-directory' and the Dired deletion commands. */);
6022 delete_by_moving_to_trash
= 0;
6023 DEFSYM (Qdelete_by_moving_to_trash
, "delete-by-moving-to-trash");
6025 /* Lisp function for moving files to trash. */
6026 DEFSYM (Qmove_file_to_trash
, "move-file-to-trash");
6028 /* Lisp function for recursively copying directories. */
6029 DEFSYM (Qcopy_directory
, "copy-directory");
6031 /* Lisp function for recursively deleting directories. */
6032 DEFSYM (Qdelete_directory
, "delete-directory");
6034 DEFSYM (Qsubstitute_env_in_file_name
, "substitute-env-in-file-name");
6035 DEFSYM (Qget_buffer_window_list
, "get-buffer-window-list");
6037 DEFSYM (Qstdin
, "stdin");
6038 DEFSYM (Qstdout
, "stdout");
6039 DEFSYM (Qstderr
, "stderr");
6041 defsubr (&Sfind_file_name_handler
);
6042 defsubr (&Sfile_name_directory
);
6043 defsubr (&Sfile_name_nondirectory
);
6044 defsubr (&Sunhandled_file_name_directory
);
6045 defsubr (&Sfile_name_as_directory
);
6046 defsubr (&Sdirectory_file_name
);
6047 defsubr (&Smake_temp_name
);
6048 defsubr (&Sexpand_file_name
);
6049 defsubr (&Ssubstitute_in_file_name
);
6050 defsubr (&Scopy_file
);
6051 defsubr (&Smake_directory_internal
);
6052 defsubr (&Sdelete_directory_internal
);
6053 defsubr (&Sdelete_file
);
6054 defsubr (&Srename_file
);
6055 defsubr (&Sadd_name_to_file
);
6056 defsubr (&Smake_symbolic_link
);
6057 defsubr (&Sfile_name_absolute_p
);
6058 defsubr (&Sfile_exists_p
);
6059 defsubr (&Sfile_executable_p
);
6060 defsubr (&Sfile_readable_p
);
6061 defsubr (&Sfile_writable_p
);
6062 defsubr (&Saccess_file
);
6063 defsubr (&Sfile_symlink_p
);
6064 defsubr (&Sfile_directory_p
);
6065 defsubr (&Sfile_accessible_directory_p
);
6066 defsubr (&Sfile_regular_p
);
6067 defsubr (&Sfile_modes
);
6068 defsubr (&Sset_file_modes
);
6069 defsubr (&Sset_file_times
);
6070 defsubr (&Sfile_selinux_context
);
6071 defsubr (&Sfile_acl
);
6072 defsubr (&Sset_file_acl
);
6073 defsubr (&Sset_file_selinux_context
);
6074 defsubr (&Sset_default_file_modes
);
6075 defsubr (&Sdefault_file_modes
);
6076 defsubr (&Sfile_newer_than_file_p
);
6077 defsubr (&Sinsert_file_contents
);
6078 defsubr (&Swrite_region
);
6079 defsubr (&Scar_less_than_car
);
6080 defsubr (&Sverify_visited_file_modtime
);
6081 defsubr (&Svisited_file_modtime
);
6082 defsubr (&Sset_visited_file_modtime
);
6083 defsubr (&Sdo_auto_save
);
6084 defsubr (&Sset_buffer_auto_saved
);
6085 defsubr (&Sclear_buffer_auto_save_failure
);
6086 defsubr (&Srecent_auto_save_p
);
6088 defsubr (&Snext_read_file_uses_dialog_p
);
6090 defsubr (&Sset_binary_mode
);
6093 defsubr (&Sunix_sync
);