1 /* File IO for GNU Emacs.
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1996,
3 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
29 #include <sys/types.h>
37 #if !defined (S_ISLNK) && defined (S_IFLNK)
38 # define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
41 #if !defined (S_ISFIFO) && defined (S_IFIFO)
42 # define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
45 #if !defined (S_ISREG) && defined (S_IFREG)
46 # define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
63 #include "intervals.h"
65 #include "character.h"
68 #include "blockinput.h"
70 #include "dispextern.h"
77 #endif /* not WINDOWSNT */
81 #include <sys/param.h>
89 #define CORRECT_DIR_SEPS(s) \
90 do { if ('/' == DIRECTORY_SEP) dostounix_filename (s); \
91 else unixtodos_filename (s); \
93 /* On Windows, drive letters must be alphabetic - on DOS, the Netware
94 redirector allows the six letters between 'Z' and 'a' as well. */
96 #define IS_DRIVE(x) ((x) >= 'A' && (x) <= 'z')
99 #define IS_DRIVE(x) isalpha (x)
101 /* Need to lower-case the drive letter, or else expanded
102 filenames will sometimes compare inequal, because
103 `expand-file-name' doesn't always down-case the drive letter. */
104 #define DRIVE_LETTER(x) (tolower (x))
113 #include "commands.h"
114 extern int use_dialog_box
;
115 extern int use_file_dialog
;
129 #ifndef FILE_SYSTEM_CASE
130 #define FILE_SYSTEM_CASE(filename) (filename)
133 /* Nonzero during writing of auto-save files */
136 /* Set by auto_save_1 to mode of original file so Fwrite_region will create
137 a new file with the same mode as the original */
138 int auto_save_mode_bits
;
140 /* Set by auto_save_1 if an error occurred during the last auto-save. */
141 int auto_save_error_occurred
;
143 /* The symbol bound to coding-system-for-read when
144 insert-file-contents is called for recovering a file. This is not
145 an actual coding system name, but just an indicator to tell
146 insert-file-contents to use `emacs-mule' with a special flag for
147 auto saving and recovering a file. */
148 Lisp_Object Qauto_save_coding
;
150 /* Coding system for file names, or nil if none. */
151 Lisp_Object impl_Vfile_name_coding_system
;
153 /* Coding system for file names used only when
154 Vfile_name_coding_system is nil. */
155 Lisp_Object impl_Vdefault_file_name_coding_system
;
157 /* Alist of elements (REGEXP . HANDLER) for file names
158 whose I/O is done with a special handler. */
159 Lisp_Object impl_Vfile_name_handler_alist
;
161 /* Property name of a file name handler,
162 which gives a list of operations it handles.. */
163 Lisp_Object Qoperations
;
165 /* Lisp functions for translating file formats */
166 Lisp_Object Qformat_decode
, Qformat_annotate_function
;
168 /* Function to be called to decide a coding system of a reading file. */
169 Lisp_Object impl_Vset_auto_coding_function
;
171 /* Functions to be called to process text properties in inserted file. */
172 Lisp_Object impl_Vafter_insert_file_functions
;
174 /* Lisp function for setting buffer-file-coding-system and the
175 multibyteness of the current buffer after inserting a file. */
176 Lisp_Object Qafter_insert_file_set_coding
;
178 /* Functions to be called to create text property annotations for file. */
179 Lisp_Object impl_Vwrite_region_annotate_functions
;
180 Lisp_Object Qwrite_region_annotate_functions
;
181 Lisp_Object impl_Vwrite_region_post_annotation_function
;
183 /* During build_annotations, each time an annotation function is called,
184 this holds the annotations made by the previous functions. */
185 Lisp_Object impl_Vwrite_region_annotations_so_far
;
187 /* Each time an annotation function changes the buffer, the new buffer
189 Lisp_Object Vwrite_region_annotation_buffers
;
191 /* File name in which we write a list of all our auto save files. */
192 Lisp_Object impl_Vauto_save_list_file_name
;
194 /* Whether or not files are auto-saved into themselves. */
195 Lisp_Object impl_Vauto_save_visited_file_name
;
197 /* Whether or not to continue auto-saving after a large deletion. */
198 Lisp_Object impl_Vauto_save_include_big_deletions
;
200 /* On NT, specifies the directory separator character, used (eg.) when
201 expanding file names. This can be bound to / or \. */
202 Lisp_Object impl_Vdirectory_sep_char
;
205 /* Nonzero means skip the call to fsync in Fwrite-region. */
206 int write_region_inhibit_fsync
;
209 /* Non-zero means call move-file-to-trash in Fdelete_file or
210 Fdelete_directory_internal. */
211 int delete_by_moving_to_trash
;
213 Lisp_Object Qdelete_by_moving_to_trash
;
215 /* Lisp function for moving files to trash. */
216 Lisp_Object Qmove_file_to_trash
;
218 /* Lisp function for recursively copying directories. */
219 Lisp_Object Qcopy_directory
;
221 /* Lisp function for recursively deleting directories. */
222 Lisp_Object Qdelete_directory
;
224 extern Lisp_Object impl_Vuser_login_name
;
227 extern Lisp_Object impl_Vw32_get_true_file_attributes
;
230 extern int minibuf_level
;
232 extern int minibuffer_auto_raise
;
234 /* These variables describe handlers that have "already" had a chance
235 to handle the current operation.
237 Vinhibit_file_name_handlers is a list of file name handlers.
238 Vinhibit_file_name_operation is the operation being handled.
239 If we try to handle that operation, we ignore those handlers. */
241 static Lisp_Object impl_Vinhibit_file_name_handlers
;
242 static Lisp_Object impl_Vinhibit_file_name_operation
;
244 Lisp_Object Qfile_error
, Qfile_already_exists
, Qfile_date_error
;
246 Lisp_Object Qfile_name_history
;
248 Lisp_Object Qcar_less_than_car
;
250 static int a_write
P_ ((int, Lisp_Object
, int, int,
251 Lisp_Object
*, struct coding_system
*));
252 static int e_write
P_ ((int, Lisp_Object
, int, int, struct coding_system
*));
256 report_file_error (string
, data
)
260 Lisp_Object errstring
;
264 synchronize_system_messages_locale ();
265 str
= strerror (errorno
);
266 errstring
= code_convert_string_norecord (make_unibyte_string (str
,
268 Vlocale_coding_system
, 0);
274 xsignal (Qfile_already_exists
, Fcons (errstring
, data
));
277 /* System error messages are capitalized. Downcase the initial
278 unless it is followed by a slash. (The slash case caters to
279 error messages that begin with "I/O" or, in German, "E/A".) */
280 if (STRING_MULTIBYTE (errstring
)
281 && ! EQ (Faref (errstring
, make_number (1)), make_number ('/')))
285 str
= (char *) SDATA (errstring
);
286 c
= STRING_CHAR (str
);
287 Faset (errstring
, make_number (0), make_number (DOWNCASE (c
)));
290 xsignal (Qfile_error
,
291 Fcons (build_string (string
), Fcons (errstring
, data
)));
296 close_file_unwind (fd
)
299 emacs_close (XFASTINT (fd
));
303 /* Restore point, having saved it as a marker. */
306 restore_point_unwind (location
)
307 Lisp_Object location
;
309 Fgoto_char (location
);
310 Fset_marker (location
, Qnil
, Qnil
);
315 Lisp_Object Qexpand_file_name
;
316 Lisp_Object Qsubstitute_in_file_name
;
317 Lisp_Object Qdirectory_file_name
;
318 Lisp_Object Qfile_name_directory
;
319 Lisp_Object Qfile_name_nondirectory
;
320 Lisp_Object Qunhandled_file_name_directory
;
321 Lisp_Object Qfile_name_as_directory
;
322 Lisp_Object Qcopy_file
;
323 Lisp_Object Qmake_directory_internal
;
324 Lisp_Object Qmake_directory
;
325 Lisp_Object Qdelete_directory_internal
;
326 Lisp_Object Qdelete_file
;
327 Lisp_Object Qrename_file
;
328 Lisp_Object Qadd_name_to_file
;
329 Lisp_Object Qmake_symbolic_link
;
330 Lisp_Object Qfile_exists_p
;
331 Lisp_Object Qfile_executable_p
;
332 Lisp_Object Qfile_readable_p
;
333 Lisp_Object Qfile_writable_p
;
334 Lisp_Object Qfile_symlink_p
;
335 Lisp_Object Qaccess_file
;
336 Lisp_Object Qfile_directory_p
;
337 Lisp_Object Qfile_regular_p
;
338 Lisp_Object Qfile_accessible_directory_p
;
339 Lisp_Object Qfile_modes
;
340 Lisp_Object Qset_file_modes
;
341 Lisp_Object Qset_file_times
;
342 Lisp_Object Qfile_newer_than_file_p
;
343 Lisp_Object Qinsert_file_contents
;
344 Lisp_Object Qwrite_region
;
345 Lisp_Object Qverify_visited_file_modtime
;
346 Lisp_Object Qset_visited_file_modtime
;
348 DEFUN ("find-file-name-handler", Ffind_file_name_handler
, Sfind_file_name_handler
, 2, 2, 0,
349 doc
: /* Return FILENAME's handler function for OPERATION, if it has one.
350 Otherwise, return nil.
351 A file name is handled if one of the regular expressions in
352 `file-name-handler-alist' matches it.
354 If OPERATION equals `inhibit-file-name-operation', then we ignore
355 any handlers that are members of `inhibit-file-name-handlers',
356 but we still do run any other handlers. This lets handlers
357 use the standard functions without calling themselves recursively. */)
358 (filename
, operation
)
359 Lisp_Object filename
, operation
;
361 /* This function must not munge the match data. */
362 Lisp_Object chain
, inhibited_handlers
, result
;
366 CHECK_STRING (filename
);
368 if (EQ (operation
, Vinhibit_file_name_operation
))
369 inhibited_handlers
= Vinhibit_file_name_handlers
;
371 inhibited_handlers
= Qnil
;
373 for (chain
= Vfile_name_handler_alist
; CONSP (chain
);
374 chain
= XCDR (chain
))
380 Lisp_Object string
= XCAR (elt
);
382 Lisp_Object handler
= XCDR (elt
);
383 Lisp_Object operations
= Qnil
;
385 if (SYMBOLP (handler
))
386 operations
= Fget (handler
, Qoperations
);
389 && (match_pos
= fast_string_match (string
, filename
)) > pos
390 && (NILP (operations
) || ! NILP (Fmemq (operation
, operations
))))
394 handler
= XCDR (elt
);
395 tem
= Fmemq (handler
, inhibited_handlers
);
409 DEFUN ("file-name-directory", Ffile_name_directory
, Sfile_name_directory
,
411 doc
: /* Return the directory component in file name FILENAME.
412 Return nil if FILENAME does not include a directory.
413 Otherwise return a directory name.
414 Given a Unix syntax file name, returns a string ending in slash. */)
416 Lisp_Object filename
;
419 register const unsigned char *beg
;
421 register unsigned char *beg
;
423 register const unsigned char *p
;
426 CHECK_STRING (filename
);
428 /* If the file name has special constructs in it,
429 call the corresponding file handler. */
430 handler
= Ffind_file_name_handler (filename
, Qfile_name_directory
);
432 return call2 (handler
, Qfile_name_directory
, filename
);
434 filename
= FILE_SYSTEM_CASE (filename
);
436 beg
= (unsigned char *) alloca (SBYTES (filename
) + 1);
437 bcopy (SDATA (filename
), beg
, SBYTES (filename
) + 1);
439 beg
= SDATA (filename
);
441 p
= beg
+ SBYTES (filename
);
443 while (p
!= beg
&& !IS_DIRECTORY_SEP (p
[-1])
445 /* only recognise drive specifier at the beginning */
447 /* handle the "/:d:foo" and "/:foo" cases correctly */
448 && ((p
== beg
+ 2 && !IS_DIRECTORY_SEP (*beg
))
449 || (p
== beg
+ 4 && IS_DIRECTORY_SEP (*beg
))))
456 /* Expansion of "c:" to drive and default directory. */
459 /* MAXPATHLEN+1 is guaranteed to be enough space for getdefdir. */
460 unsigned char *res
= alloca (MAXPATHLEN
+ 1);
461 unsigned char *r
= res
;
463 if (p
== beg
+ 4 && IS_DIRECTORY_SEP (*beg
) && beg
[1] == ':')
465 strncpy (res
, beg
, 2);
470 if (getdefdir (toupper (*beg
) - 'A' + 1, r
))
472 if (!IS_DIRECTORY_SEP (res
[strlen (res
) - 1]))
475 p
= beg
+ strlen (beg
);
478 CORRECT_DIR_SEPS (beg
);
481 return make_specified_string (beg
, -1, p
- beg
, STRING_MULTIBYTE (filename
));
484 DEFUN ("file-name-nondirectory", Ffile_name_nondirectory
,
485 Sfile_name_nondirectory
, 1, 1, 0,
486 doc
: /* Return file name FILENAME sans its directory.
487 For example, in a Unix-syntax file name,
488 this is everything after the last slash,
489 or the entire name if it contains no slash. */)
491 Lisp_Object filename
;
493 register const unsigned char *beg
, *p
, *end
;
496 CHECK_STRING (filename
);
498 /* If the file name has special constructs in it,
499 call the corresponding file handler. */
500 handler
= Ffind_file_name_handler (filename
, Qfile_name_nondirectory
);
502 return call2 (handler
, Qfile_name_nondirectory
, filename
);
504 beg
= SDATA (filename
);
505 end
= p
= beg
+ SBYTES (filename
);
507 while (p
!= beg
&& !IS_DIRECTORY_SEP (p
[-1])
509 /* only recognise drive specifier at beginning */
511 /* handle the "/:d:foo" case correctly */
512 && (p
== beg
+ 2 || (p
== beg
+ 4 && IS_DIRECTORY_SEP (*beg
))))
517 return make_specified_string (p
, -1, end
- p
, STRING_MULTIBYTE (filename
));
520 DEFUN ("unhandled-file-name-directory", Funhandled_file_name_directory
,
521 Sunhandled_file_name_directory
, 1, 1, 0,
522 doc
: /* Return a directly usable directory name somehow associated with FILENAME.
523 A `directly usable' directory name is one that may be used without the
524 intervention of any file handler.
525 If FILENAME is a directly usable file itself, return
526 \(file-name-directory FILENAME).
527 If FILENAME refers to a file which is not accessible from a local process,
528 then this should return nil.
529 The `call-process' and `start-process' functions use this function to
530 get a current directory to run processes in. */)
532 Lisp_Object filename
;
536 /* If the file name has special constructs in it,
537 call the corresponding file handler. */
538 handler
= Ffind_file_name_handler (filename
, Qunhandled_file_name_directory
);
540 return call2 (handler
, Qunhandled_file_name_directory
, filename
);
542 return Ffile_name_directory (filename
);
547 file_name_as_directory (out
, in
)
550 int size
= strlen (in
) - 1;
562 /* For Unix syntax, Append a slash if necessary */
563 if (!IS_DIRECTORY_SEP (out
[size
]))
565 /* Cannot use DIRECTORY_SEP, which could have any value */
567 out
[size
+ 2] = '\0';
570 CORRECT_DIR_SEPS (out
);
575 DEFUN ("file-name-as-directory", Ffile_name_as_directory
,
576 Sfile_name_as_directory
, 1, 1, 0,
577 doc
: /* Return a string representing the file name FILE interpreted as a directory.
578 This operation exists because a directory is also a file, but its name as
579 a directory is different from its name as a file.
580 The result can be used as the value of `default-directory'
581 or passed as second argument to `expand-file-name'.
582 For a Unix-syntax file name, just appends a slash. */)
593 /* If the file name has special constructs in it,
594 call the corresponding file handler. */
595 handler
= Ffind_file_name_handler (file
, Qfile_name_as_directory
);
597 return call2 (handler
, Qfile_name_as_directory
, file
);
599 buf
= (char *) alloca (SBYTES (file
) + 10);
600 file_name_as_directory (buf
, SDATA (file
));
601 return make_specified_string (buf
, -1, strlen (buf
),
602 STRING_MULTIBYTE (file
));
606 * Convert from directory name to filename.
607 * On UNIX, it's simple: just make sure there isn't a terminating /
609 * Value is nonzero if the string output is different from the input.
613 directory_file_name (src
, dst
)
620 /* Process as Unix format: just remove any final slash.
621 But leave "/" unchanged; do not change it to "". */
624 && IS_DIRECTORY_SEP (dst
[slen
- 1])
626 && !IS_ANY_SEP (dst
[slen
- 2])
631 CORRECT_DIR_SEPS (dst
);
636 DEFUN ("directory-file-name", Fdirectory_file_name
, Sdirectory_file_name
,
638 doc
: /* Returns the file name of the directory named DIRECTORY.
639 This is the name of the file that holds the data for the directory DIRECTORY.
640 This operation exists because a directory is also a file, but its name as
641 a directory is different from its name as a file.
642 In Unix-syntax, this function just removes the final slash. */)
644 Lisp_Object directory
;
649 CHECK_STRING (directory
);
651 if (NILP (directory
))
654 /* If the file name has special constructs in it,
655 call the corresponding file handler. */
656 handler
= Ffind_file_name_handler (directory
, Qdirectory_file_name
);
658 return call2 (handler
, Qdirectory_file_name
, directory
);
660 buf
= (char *) alloca (SBYTES (directory
) + 20);
661 directory_file_name (SDATA (directory
), buf
);
662 return make_specified_string (buf
, -1, strlen (buf
),
663 STRING_MULTIBYTE (directory
));
666 static const char make_temp_name_tbl
[64] =
668 'A','B','C','D','E','F','G','H',
669 'I','J','K','L','M','N','O','P',
670 'Q','R','S','T','U','V','W','X',
671 'Y','Z','a','b','c','d','e','f',
672 'g','h','i','j','k','l','m','n',
673 'o','p','q','r','s','t','u','v',
674 'w','x','y','z','0','1','2','3',
675 '4','5','6','7','8','9','-','_'
678 static unsigned make_temp_name_count
, make_temp_name_count_initialized_p
;
680 /* Value is a temporary file name starting with PREFIX, a string.
682 The Emacs process number forms part of the result, so there is
683 no danger of generating a name being used by another process.
684 In addition, this function makes an attempt to choose a name
685 which has no existing file. To make this work, PREFIX should be
686 an absolute file name.
688 BASE64_P non-zero means add the pid as 3 characters in base64
689 encoding. In this case, 6 characters will be added to PREFIX to
690 form the file name. Otherwise, if Emacs is running on a system
691 with long file names, add the pid as a decimal number.
693 This function signals an error if no unique file name could be
697 make_temp_name (prefix
, base64_p
)
704 unsigned char *p
, *data
;
708 CHECK_STRING (prefix
);
710 /* VAL is created by adding 6 characters to PREFIX. The first
711 three are the PID of this process, in base 64, and the second
712 three are incremented if the file already exists. This ensures
713 262144 unique file names per PID per PREFIX. */
715 pid
= (int) getpid ();
719 pidbuf
[0] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
720 pidbuf
[1] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
721 pidbuf
[2] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
726 #ifdef HAVE_LONG_FILE_NAMES
727 sprintf (pidbuf
, "%d", pid
);
728 pidlen
= strlen (pidbuf
);
730 pidbuf
[0] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
731 pidbuf
[1] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
732 pidbuf
[2] = make_temp_name_tbl
[pid
& 63], pid
>>= 6;
737 len
= SBYTES (prefix
); clen
= SCHARS (prefix
);
738 val
= make_uninit_multibyte_string (clen
+ 3 + pidlen
, len
+ 3 + pidlen
);
739 if (!STRING_MULTIBYTE (prefix
))
740 STRING_SET_UNIBYTE (val
);
742 bcopy(SDATA (prefix
), data
, len
);
745 bcopy (pidbuf
, p
, pidlen
);
748 /* Here we try to minimize useless stat'ing when this function is
749 invoked many times successively with the same PREFIX. We achieve
750 this by initializing count to a random value, and incrementing it
753 We don't want make-temp-name to be called while dumping,
754 because then make_temp_name_count_initialized_p would get set
755 and then make_temp_name_count would not be set when Emacs starts. */
757 if (!make_temp_name_count_initialized_p
)
759 make_temp_name_count
= (unsigned) time (NULL
);
760 make_temp_name_count_initialized_p
= 1;
766 unsigned num
= make_temp_name_count
;
768 p
[0] = make_temp_name_tbl
[num
& 63], num
>>= 6;
769 p
[1] = make_temp_name_tbl
[num
& 63], num
>>= 6;
770 p
[2] = make_temp_name_tbl
[num
& 63], num
>>= 6;
772 /* Poor man's congruential RN generator. Replace with
773 ++make_temp_name_count for debugging. */
774 make_temp_name_count
+= 25229;
775 make_temp_name_count
%= 225307;
777 if (stat (data
, &ignored
) < 0)
779 /* We want to return only if errno is ENOENT. */
783 /* The error here is dubious, but there is little else we
784 can do. The alternatives are to return nil, which is
785 as bad as (and in many cases worse than) throwing the
786 error, or to ignore the error, which will likely result
787 in looping through 225307 stat's, which is not only
788 dog-slow, but also useless since it will fallback to
789 the errow below, anyway. */
790 report_file_error ("Cannot create temporary name for prefix",
791 Fcons (prefix
, Qnil
));
796 error ("Cannot create temporary name for prefix `%s'",
802 DEFUN ("make-temp-name", Fmake_temp_name
, Smake_temp_name
, 1, 1, 0,
803 doc
: /* Generate temporary file name (string) starting with PREFIX (a string).
804 The Emacs process number forms part of the result,
805 so there is no danger of generating a name being used by another process.
807 In addition, this function makes an attempt to choose a name
808 which has no existing file. To make this work,
809 PREFIX should be an absolute file name.
811 There is a race condition between calling `make-temp-name' and creating the
812 file which opens all kinds of security holes. For that reason, you should
813 probably use `make-temp-file' instead, except in three circumstances:
815 * If you are creating the file in the user's home directory.
816 * If you are creating a directory rather than an ordinary file.
817 * If you are taking special precautions as `make-temp-file' does. */)
821 return make_temp_name (prefix
, 0);
826 DEFUN ("expand-file-name", Fexpand_file_name
, Sexpand_file_name
, 1, 2, 0,
827 doc
: /* Convert filename NAME to absolute, and canonicalize it.
828 Second arg DEFAULT-DIRECTORY is directory to start with if NAME is relative
829 \(does not start with slash or tilde); if DEFAULT-DIRECTORY is nil or missing,
830 the current buffer's value of `default-directory' is used.
831 File name components that are `.' are removed, and
832 so are file name components followed by `..', along with the `..' itself;
833 note that these simplifications are done without checking the resulting
834 file names in the file system.
835 An initial `~/' expands to your home directory.
836 An initial `~USER/' expands to USER's home directory.
837 See also the function `substitute-in-file-name'.
839 For technical reasons, this function can return correct but
840 non-intuitive results for the root directory; for instance,
841 \(expand-file-name ".." "/") returns "/..". For this reason, use
842 (directory-file-name (file-name-directory dirname)) to traverse a
843 filesystem tree, not (expand-file-name ".." dirname). */)
844 (name
, default_directory
)
845 Lisp_Object name
, default_directory
;
847 /* These point to SDATA and need to be careful with string-relocation
848 during GC (via DECODE_FILE). */
849 unsigned char *nm
, *newdir
;
850 /* This should only point to alloca'd data. */
851 unsigned char *target
;
857 int collapse_newdir
= 1;
861 Lisp_Object handler
, result
;
867 /* If the file name has special constructs in it,
868 call the corresponding file handler. */
869 handler
= Ffind_file_name_handler (name
, Qexpand_file_name
);
871 return call3 (handler
, Qexpand_file_name
, name
, default_directory
);
873 /* Use the buffer's default-directory if DEFAULT_DIRECTORY is omitted. */
874 if (NILP (default_directory
))
875 default_directory
= current_buffer
->directory
;
876 if (! STRINGP (default_directory
))
879 /* "/" is not considered a root directory on DOS_NT, so using "/"
880 here causes an infinite recursion in, e.g., the following:
882 (let (default-directory)
883 (expand-file-name "a"))
885 To avoid this, we set default_directory to the root of the
887 extern char *emacs_root_dir (void);
889 default_directory
= build_string (emacs_root_dir ());
891 default_directory
= build_string ("/");
895 if (!NILP (default_directory
))
897 handler
= Ffind_file_name_handler (default_directory
, Qexpand_file_name
);
899 return call3 (handler
, Qexpand_file_name
, name
, default_directory
);
903 unsigned char *o
= SDATA (default_directory
);
905 /* Make sure DEFAULT_DIRECTORY is properly expanded.
906 It would be better to do this down below where we actually use
907 default_directory. Unfortunately, calling Fexpand_file_name recursively
908 could invoke GC, and the strings might be relocated. This would
909 be annoying because we have pointers into strings lying around
910 that would need adjusting, and people would add new pointers to
911 the code and forget to adjust them, resulting in intermittent bugs.
912 Putting this call here avoids all that crud.
914 The EQ test avoids infinite recursion. */
915 if (! NILP (default_directory
) && !EQ (default_directory
, name
)
916 /* Save time in some common cases - as long as default_directory
917 is not relative, it can be canonicalized with name below (if it
918 is needed at all) without requiring it to be expanded now. */
920 /* Detect MSDOS file names with drive specifiers. */
921 && ! (IS_DRIVE (o
[0]) && IS_DEVICE_SEP (o
[1])
922 && IS_DIRECTORY_SEP (o
[2]))
924 /* Detect Windows file names in UNC format. */
925 && ! (IS_DIRECTORY_SEP (o
[0]) && IS_DIRECTORY_SEP (o
[1]))
927 #else /* not DOS_NT */
928 /* Detect Unix absolute file names (/... alone is not absolute on
930 && ! (IS_DIRECTORY_SEP (o
[0]))
931 #endif /* not DOS_NT */
937 default_directory
= Fexpand_file_name (default_directory
, Qnil
);
941 name
= FILE_SYSTEM_CASE (name
);
942 multibyte
= STRING_MULTIBYTE (name
);
943 if (multibyte
!= STRING_MULTIBYTE (default_directory
))
946 default_directory
= string_to_multibyte (default_directory
);
949 name
= string_to_multibyte (name
);
954 /* Make a local copy of nm[] to protect it from GC in DECODE_FILE below. */
955 nm
= (unsigned char *) alloca (SBYTES (name
) + 1);
956 bcopy (SDATA (name
), nm
, SBYTES (name
) + 1);
959 /* Note if special escape prefix is present, but remove for now. */
960 if (nm
[0] == '/' && nm
[1] == ':')
966 /* Find and remove drive specifier if present; this makes nm absolute
967 even if the rest of the name appears to be relative. Only look for
968 drive specifier at the beginning. */
969 if (IS_DRIVE (nm
[0]) && IS_DEVICE_SEP (nm
[1]))
976 /* If we see "c://somedir", we want to strip the first slash after the
977 colon when stripping the drive letter. Otherwise, this expands to
979 if (drive
&& IS_DIRECTORY_SEP (nm
[0]) && IS_DIRECTORY_SEP (nm
[1]))
982 /* Discard any previous drive specifier if nm is now in UNC format. */
983 if (IS_DIRECTORY_SEP (nm
[0]) && IS_DIRECTORY_SEP (nm
[1]))
987 #endif /* WINDOWSNT */
990 /* If nm is absolute, look for `/./' or `/../' or `//''sequences; if
991 none are found, we can probably return right away. We will avoid
992 allocating a new string if name is already fully expanded. */
994 IS_DIRECTORY_SEP (nm
[0])
996 && drive
&& !is_escaped
999 && (drive
|| IS_DIRECTORY_SEP (nm
[1])) && !is_escaped
1003 /* If it turns out that the filename we want to return is just a
1004 suffix of FILENAME, we don't need to go through and edit
1005 things; we just need to construct a new string using data
1006 starting at the middle of FILENAME. If we set lose to a
1007 non-zero value, that means we've discovered that we can't do
1010 unsigned char *p
= nm
;
1014 /* Since we know the name is absolute, we can assume that each
1015 element starts with a "/". */
1017 /* "." and ".." are hairy. */
1018 if (IS_DIRECTORY_SEP (p
[0])
1020 && (IS_DIRECTORY_SEP (p
[2])
1022 || (p
[2] == '.' && (IS_DIRECTORY_SEP (p
[3])
1025 /* We want to replace multiple `/' in a row with a single
1028 && IS_DIRECTORY_SEP (p
[0])
1029 && IS_DIRECTORY_SEP (p
[1]))
1036 /* Make sure directories are all separated with / or \ as
1037 desired, but avoid allocation of a new string when not
1039 CORRECT_DIR_SEPS (nm
);
1041 if (IS_DIRECTORY_SEP (nm
[1]))
1043 if (strcmp (nm
, SDATA (name
)) != 0)
1044 name
= make_specified_string (nm
, -1, strlen (nm
), multibyte
);
1048 /* drive must be set, so this is okay */
1049 if (strcmp (nm
- 2, SDATA (name
)) != 0)
1053 name
= make_specified_string (nm
, -1, p
- nm
, multibyte
);
1054 temp
[0] = DRIVE_LETTER (drive
);
1055 name
= concat2 (build_string (temp
), name
);
1058 #else /* not DOS_NT */
1059 if (strcmp (nm
, SDATA (name
)) == 0)
1061 return make_specified_string (nm
, -1, strlen (nm
), multibyte
);
1062 #endif /* not DOS_NT */
1066 /* At this point, nm might or might not be an absolute file name. We
1067 need to expand ~ or ~user if present, otherwise prefix nm with
1068 default_directory if nm is not absolute, and finally collapse /./
1069 and /foo/../ sequences.
1071 We set newdir to be the appropriate prefix if one is needed:
1072 - the relevant user directory if nm starts with ~ or ~user
1073 - the specified drive's working dir (DOS/NT only) if nm does not
1075 - the value of default_directory.
1077 Note that these prefixes are not guaranteed to be absolute (except
1078 for the working dir of a drive). Therefore, to ensure we always
1079 return an absolute name, if the final prefix is not absolute we
1080 append it to the current working directory. */
1084 if (nm
[0] == '~') /* prefix ~ */
1086 if (IS_DIRECTORY_SEP (nm
[1])
1087 || nm
[1] == 0) /* ~ by itself */
1091 if (!(newdir
= (unsigned char *) egetenv ("HOME")))
1092 newdir
= (unsigned char *) "";
1094 /* egetenv may return a unibyte string, which will bite us since
1095 we expect the directory to be multibyte. */
1096 tem
= build_string (newdir
);
1097 if (!STRING_MULTIBYTE (tem
))
1099 hdir
= DECODE_FILE (tem
);
1100 newdir
= SDATA (hdir
);
1103 collapse_newdir
= 0;
1106 else /* ~user/filename */
1108 unsigned char *o
, *p
;
1109 for (p
= nm
; *p
&& (!IS_DIRECTORY_SEP (*p
)); p
++);
1110 o
= alloca (p
- nm
+ 1);
1111 bcopy ((char *) nm
, o
, p
- nm
);
1115 pw
= (struct passwd
*) getpwnam (o
+ 1);
1119 newdir
= (unsigned char *) pw
-> pw_dir
;
1122 collapse_newdir
= 0;
1126 /* If we don't find a user of that name, leave the name
1127 unchanged; don't move nm forward to p. */
1132 /* On DOS and Windows, nm is absolute if a drive name was specified;
1133 use the drive's current directory as the prefix if needed. */
1134 if (!newdir
&& drive
)
1136 /* Get default directory if needed to make nm absolute. */
1137 if (!IS_DIRECTORY_SEP (nm
[0]))
1139 newdir
= alloca (MAXPATHLEN
+ 1);
1140 if (!getdefdir (toupper (drive
) - 'A' + 1, newdir
))
1145 /* Either nm starts with /, or drive isn't mounted. */
1146 newdir
= alloca (4);
1147 newdir
[0] = DRIVE_LETTER (drive
);
1155 /* Finally, if no prefix has been specified and nm is not absolute,
1156 then it must be expanded relative to default_directory. */
1160 /* /... alone is not absolute on DOS and Windows. */
1161 && !IS_DIRECTORY_SEP (nm
[0])
1164 && !(IS_DIRECTORY_SEP (nm
[0]) && IS_DIRECTORY_SEP (nm
[1]))
1168 newdir
= SDATA (default_directory
);
1170 /* Note if special escape prefix is present, but remove for now. */
1171 if (newdir
[0] == '/' && newdir
[1] == ':')
1182 /* First ensure newdir is an absolute name. */
1184 /* Detect MSDOS file names with drive specifiers. */
1185 ! (IS_DRIVE (newdir
[0])
1186 && IS_DEVICE_SEP (newdir
[1]) && IS_DIRECTORY_SEP (newdir
[2]))
1188 /* Detect Windows file names in UNC format. */
1189 && ! (IS_DIRECTORY_SEP (newdir
[0]) && IS_DIRECTORY_SEP (newdir
[1]))
1193 /* Effectively, let newdir be (expand-file-name newdir cwd).
1194 Because of the admonition against calling expand-file-name
1195 when we have pointers into lisp strings, we accomplish this
1196 indirectly by prepending newdir to nm if necessary, and using
1197 cwd (or the wd of newdir's drive) as the new newdir. */
1199 if (IS_DRIVE (newdir
[0]) && IS_DEVICE_SEP (newdir
[1]))
1204 if (!IS_DIRECTORY_SEP (nm
[0]))
1206 char * tmp
= alloca (strlen (newdir
) + strlen (nm
) + 2);
1207 file_name_as_directory (tmp
, newdir
);
1211 newdir
= alloca (MAXPATHLEN
+ 1);
1214 if (!getdefdir (toupper (drive
) - 'A' + 1, newdir
))
1221 /* Strip off drive name from prefix, if present. */
1222 if (IS_DRIVE (newdir
[0]) && IS_DEVICE_SEP (newdir
[1]))
1228 /* Keep only a prefix from newdir if nm starts with slash
1229 (//server/share for UNC, nothing otherwise). */
1230 if (IS_DIRECTORY_SEP (nm
[0]) && collapse_newdir
)
1233 if (IS_DIRECTORY_SEP (newdir
[0]) && IS_DIRECTORY_SEP (newdir
[1]))
1236 newdir
= strcpy (alloca (strlen (newdir
) + 1), newdir
);
1238 while (*p
&& !IS_DIRECTORY_SEP (*p
)) p
++;
1240 while (*p
&& !IS_DIRECTORY_SEP (*p
)) p
++;
1252 /* Get rid of any slash at the end of newdir, unless newdir is
1253 just / or // (an incomplete UNC name). */
1254 length
= strlen (newdir
);
1255 if (length
> 1 && IS_DIRECTORY_SEP (newdir
[length
- 1])
1257 && !(length
== 2 && IS_DIRECTORY_SEP (newdir
[0]))
1261 unsigned char *temp
= (unsigned char *) alloca (length
);
1262 bcopy (newdir
, temp
, length
- 1);
1263 temp
[length
- 1] = 0;
1271 /* Now concatenate the directory and name to new space in the stack frame */
1272 tlen
+= strlen (nm
) + 1;
1274 /* Reserve space for drive specifier and escape prefix, since either
1275 or both may need to be inserted. (The Microsoft x86 compiler
1276 produces incorrect code if the following two lines are combined.) */
1277 target
= (unsigned char *) alloca (tlen
+ 4);
1279 #else /* not DOS_NT */
1280 target
= (unsigned char *) alloca (tlen
);
1281 #endif /* not DOS_NT */
1286 if (nm
[0] == 0 || IS_DIRECTORY_SEP (nm
[0]))
1289 /* If newdir is effectively "C:/", then the drive letter will have
1290 been stripped and newdir will be "/". Concatenating with an
1291 absolute directory in nm produces "//", which will then be
1292 incorrectly treated as a network share. Ignore newdir in
1293 this case (keeping the drive letter). */
1294 if (!(drive
&& nm
[0] && IS_DIRECTORY_SEP (newdir
[0])
1295 && newdir
[1] == '\0'))
1297 strcpy (target
, newdir
);
1300 file_name_as_directory (target
, newdir
);
1303 strcat (target
, nm
);
1305 /* Now canonicalize by removing `//', `/.' and `/foo/..' if they
1308 unsigned char *p
= target
;
1309 unsigned char *o
= target
;
1313 if (!IS_DIRECTORY_SEP (*p
))
1317 else if (p
[1] == '.'
1318 && (IS_DIRECTORY_SEP (p
[2])
1321 /* If "/." is the entire filename, keep the "/". Otherwise,
1322 just delete the whole "/.". */
1323 if (o
== target
&& p
[2] == '\0')
1327 else if (p
[1] == '.' && p
[2] == '.'
1328 /* `/../' is the "superroot" on certain file systems.
1329 Turned off on DOS_NT systems because they have no
1330 "superroot" and because this causes us to produce
1331 file names like "d:/../foo" which fail file-related
1332 functions of the underlying OS. (To reproduce, try a
1333 long series of "../../" in default_directory, longer
1334 than the number of levels from the root.) */
1338 && (IS_DIRECTORY_SEP (p
[3]) || p
[3] == 0))
1341 unsigned char *prev_o
= o
;
1343 while (o
!= target
&& (--o
) && !IS_DIRECTORY_SEP (*o
))
1346 /* Don't go below server level in UNC filenames. */
1347 if (o
== target
+ 1 && IS_DIRECTORY_SEP (*o
)
1348 && IS_DIRECTORY_SEP (*target
))
1352 /* Keep initial / only if this is the whole name. */
1353 if (o
== target
&& IS_ANY_SEP (*o
) && p
[3] == 0)
1357 else if (p
> target
&& IS_DIRECTORY_SEP (p
[1]))
1358 /* Collapse multiple `/' in a row. */
1367 /* At last, set drive name. */
1369 /* Except for network file name. */
1370 if (!(IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1])))
1371 #endif /* WINDOWSNT */
1373 if (!drive
) abort ();
1375 target
[0] = DRIVE_LETTER (drive
);
1378 /* Reinsert the escape prefix if required. */
1385 CORRECT_DIR_SEPS (target
);
1388 result
= make_specified_string (target
, -1, o
- target
, multibyte
);
1391 /* Again look to see if the file name has special constructs in it
1392 and perhaps call the corresponding file handler. This is needed
1393 for filenames such as "/foo/../user@host:/bar/../baz". Expanding
1394 the ".." component gives us "/user@host:/bar/../baz" which needs
1395 to be expanded again. */
1396 handler
= Ffind_file_name_handler (result
, Qexpand_file_name
);
1397 if (!NILP (handler
))
1398 return call3 (handler
, Qexpand_file_name
, result
, default_directory
);
1404 /* PLEASE DO NOT DELETE THIS COMMENTED-OUT VERSION!
1405 This is the old version of expand-file-name, before it was thoroughly
1406 rewritten for Emacs 10.31. We leave this version here commented-out,
1407 because the code is very complex and likely to have subtle bugs. If
1408 bugs _are_ found, it might be of interest to look at the old code and
1409 see what did it do in the relevant situation.
1411 Don't remove this code: it's true that it will be accessible
1412 from the repository, but a few years from deletion, people will
1413 forget it is there. */
1415 /* Changed this DEFUN to a DEAFUN, so as not to confuse `make-docfile'. */
1416 DEAFUN ("expand-file-name", Fexpand_file_name
, Sexpand_file_name
, 1, 2, 0,
1417 "Convert FILENAME to absolute, and canonicalize it.\n\
1418 Second arg DEFAULT is directory to start with if FILENAME is relative\n\
1419 \(does not start with slash); if DEFAULT is nil or missing,\n\
1420 the current buffer's value of default-directory is used.\n\
1421 Filenames containing `.' or `..' as components are simplified;\n\
1422 initial `~/' expands to your home directory.\n\
1423 See also the function `substitute-in-file-name'.")
1425 Lisp_Object name
, defalt
;
1429 register unsigned char *newdir
, *p
, *o
;
1431 unsigned char *target
;
1435 CHECK_STRING (name
);
1438 /* If nm is absolute, flush ...// and detect /./ and /../.
1439 If no /./ or /../ we can return right away. */
1446 if (p
[0] == '/' && p
[1] == '/'
1449 if (p
[0] == '/' && p
[1] == '~')
1450 nm
= p
+ 1, lose
= 1;
1451 if (p
[0] == '/' && p
[1] == '.'
1452 && (p
[2] == '/' || p
[2] == 0
1453 || (p
[2] == '.' && (p
[3] == '/' || p
[3] == 0))))
1459 if (nm
== SDATA (name
))
1461 return build_string (nm
);
1465 /* Now determine directory to start with and put it in NEWDIR */
1469 if (nm
[0] == '~') /* prefix ~ */
1470 if (nm
[1] == '/' || nm
[1] == 0)/* ~/filename */
1472 if (!(newdir
= (unsigned char *) egetenv ("HOME")))
1473 newdir
= (unsigned char *) "";
1476 else /* ~user/filename */
1478 /* Get past ~ to user */
1479 unsigned char *user
= nm
+ 1;
1480 /* Find end of name. */
1481 unsigned char *ptr
= (unsigned char *) index (user
, '/');
1482 int len
= ptr
? ptr
- user
: strlen (user
);
1483 /* Copy the user name into temp storage. */
1484 o
= (unsigned char *) alloca (len
+ 1);
1485 bcopy ((char *) user
, o
, len
);
1488 /* Look up the user name. */
1490 pw
= (struct passwd
*) getpwnam (o
+ 1);
1493 error ("\"%s\" isn't a registered user", o
+ 1);
1495 newdir
= (unsigned char *) pw
->pw_dir
;
1497 /* Discard the user name from NM. */
1501 if (nm
[0] != '/' && !newdir
)
1504 defalt
= current_buffer
->directory
;
1505 CHECK_STRING (defalt
);
1506 newdir
= SDATA (defalt
);
1509 /* Now concatenate the directory and name to new space in the stack frame */
1511 tlen
= (newdir
? strlen (newdir
) + 1 : 0) + strlen (nm
) + 1;
1512 target
= (unsigned char *) alloca (tlen
);
1517 if (nm
[0] == 0 || nm
[0] == '/')
1518 strcpy (target
, newdir
);
1520 file_name_as_directory (target
, newdir
);
1523 strcat (target
, nm
);
1525 /* Now canonicalize by removing /. and /foo/.. if they appear */
1536 else if (!strncmp (p
, "//", 2)
1542 else if (p
[0] == '/' && p
[1] == '.'
1543 && (p
[2] == '/' || p
[2] == 0))
1545 else if (!strncmp (p
, "/..", 3)
1546 /* `/../' is the "superroot" on certain file systems. */
1548 && (p
[3] == '/' || p
[3] == 0))
1550 while (o
!= target
&& *--o
!= '/')
1552 if (o
== target
&& *o
== '/')
1562 return make_string (target
, o
- target
);
1566 /* If /~ or // appears, discard everything through first slash. */
1568 file_name_absolute_p (filename
)
1569 const unsigned char *filename
;
1572 (IS_DIRECTORY_SEP (*filename
) || *filename
== '~'
1574 || (IS_DRIVE (*filename
) && IS_DEVICE_SEP (filename
[1])
1575 && IS_DIRECTORY_SEP (filename
[2]))
1580 static unsigned char *
1581 search_embedded_absfilename (nm
, endp
)
1582 unsigned char *nm
, *endp
;
1584 unsigned char *p
, *s
;
1586 for (p
= nm
+ 1; p
< endp
; p
++)
1589 || IS_DIRECTORY_SEP (p
[-1]))
1590 && file_name_absolute_p (p
)
1591 #if defined (WINDOWSNT) || defined(CYGWIN)
1592 /* // at start of file name is meaningful in Apollo,
1593 WindowsNT and Cygwin systems. */
1594 && !(IS_DIRECTORY_SEP (p
[0]) && p
- 1 == nm
)
1595 #endif /* not (WINDOWSNT || CYGWIN) */
1598 for (s
= p
; *s
&& (!IS_DIRECTORY_SEP (*s
)); s
++);
1599 if (p
[0] == '~' && s
> p
+ 1) /* we've got "/~something/" */
1601 unsigned char *o
= alloca (s
- p
+ 1);
1603 bcopy (p
, o
, s
- p
);
1606 /* If we have ~user and `user' exists, discard
1607 everything up to ~. But if `user' does not exist, leave
1608 ~user alone, it might be a literal file name. */
1610 pw
= getpwnam (o
+ 1);
1622 DEFUN ("substitute-in-file-name", Fsubstitute_in_file_name
,
1623 Ssubstitute_in_file_name
, 1, 1, 0,
1624 doc
: /* Substitute environment variables referred to in FILENAME.
1625 `$FOO' where FOO is an environment variable name means to substitute
1626 the value of that variable. The variable name should be terminated
1627 with a character not a letter, digit or underscore; otherwise, enclose
1628 the entire variable name in braces.
1630 If `/~' appears, all of FILENAME through that `/' is discarded.
1631 If `//' appears, everything up to and including the first of
1632 those `/' is discarded. */)
1634 Lisp_Object filename
;
1638 register unsigned char *s
, *p
, *o
, *x
, *endp
;
1639 unsigned char *target
= NULL
;
1641 int substituted
= 0;
1644 Lisp_Object handler
;
1646 CHECK_STRING (filename
);
1648 multibyte
= STRING_MULTIBYTE (filename
);
1650 /* If the file name has special constructs in it,
1651 call the corresponding file handler. */
1652 handler
= Ffind_file_name_handler (filename
, Qsubstitute_in_file_name
);
1653 if (!NILP (handler
))
1654 return call2 (handler
, Qsubstitute_in_file_name
, filename
);
1656 /* Always work on a copy of the string, in case GC happens during
1657 decode of environment variables, causing the original Lisp_String
1658 data to be relocated. */
1659 nm
= (unsigned char *) alloca (SBYTES (filename
) + 1);
1660 bcopy (SDATA (filename
), nm
, SBYTES (filename
) + 1);
1663 CORRECT_DIR_SEPS (nm
);
1664 substituted
= (strcmp (nm
, SDATA (filename
)) != 0);
1666 endp
= nm
+ SBYTES (filename
);
1668 /* If /~ or // appears, discard everything through first slash. */
1669 p
= search_embedded_absfilename (nm
, endp
);
1671 /* Start over with the new string, so we check the file-name-handler
1672 again. Important with filenames like "/home/foo//:/hello///there"
1673 which whould substitute to "/:/hello///there" rather than "/there". */
1674 return Fsubstitute_in_file_name
1675 (make_specified_string (p
, -1, endp
- p
, multibyte
));
1677 /* See if any variables are substituted into the string
1678 and find the total length of their values in `total' */
1680 for (p
= nm
; p
!= endp
;)
1690 /* "$$" means a single "$" */
1699 while (p
!= endp
&& *p
!= '}') p
++;
1700 if (*p
!= '}') goto missingclose
;
1706 while (p
!= endp
&& (isalnum (*p
) || *p
== '_')) p
++;
1710 /* Copy out the variable name */
1711 target
= (unsigned char *) alloca (s
- o
+ 1);
1712 strncpy (target
, o
, s
- o
);
1715 strupr (target
); /* $home == $HOME etc. */
1718 /* Get variable value */
1719 o
= (unsigned char *) egetenv (target
);
1722 /* Don't try to guess a maximum length - UTF8 can use up to
1723 four bytes per character. This code is unlikely to run
1724 in a situation that requires performance, so decoding the
1725 env variables twice should be acceptable. Note that
1726 decoding may cause a garbage collect. */
1727 Lisp_Object orig
, decoded
;
1728 orig
= make_unibyte_string (o
, strlen (o
));
1729 decoded
= DECODE_FILE (orig
);
1730 total
+= SBYTES (decoded
);
1740 /* If substitution required, recopy the string and do it */
1741 /* Make space in stack frame for the new copy */
1742 xnm
= (unsigned char *) alloca (SBYTES (filename
) + total
+ 1);
1745 /* Copy the rest of the name through, replacing $ constructs with values */
1762 while (p
!= endp
&& *p
!= '}') p
++;
1763 if (*p
!= '}') goto missingclose
;
1769 while (p
!= endp
&& (isalnum (*p
) || *p
== '_')) p
++;
1773 /* Copy out the variable name */
1774 target
= (unsigned char *) alloca (s
- o
+ 1);
1775 strncpy (target
, o
, s
- o
);
1778 strupr (target
); /* $home == $HOME etc. */
1781 /* Get variable value */
1782 o
= (unsigned char *) egetenv (target
);
1786 strcpy (x
, target
); x
+= strlen (target
);
1790 Lisp_Object orig
, decoded
;
1791 int orig_length
, decoded_length
;
1792 orig_length
= strlen (o
);
1793 orig
= make_unibyte_string (o
, orig_length
);
1794 decoded
= DECODE_FILE (orig
);
1795 decoded_length
= SBYTES (decoded
);
1796 strncpy (x
, SDATA (decoded
), decoded_length
);
1797 x
+= decoded_length
;
1799 /* If environment variable needed decoding, return value
1800 needs to be multibyte. */
1801 if (decoded_length
!= orig_length
1802 || strncmp (SDATA (decoded
), o
, orig_length
))
1809 /* If /~ or // appears, discard everything through first slash. */
1810 while ((p
= search_embedded_absfilename (xnm
, x
)))
1811 /* This time we do not start over because we've already expanded envvars
1812 and replaced $$ with $. Maybe we should start over as well, but we'd
1813 need to quote some $ to $$ first. */
1816 return make_specified_string (xnm
, -1, x
- xnm
, multibyte
);
1819 error ("Bad format environment-variable substitution");
1821 error ("Missing \"}\" in environment-variable substitution");
1823 error ("Substituting nonexistent environment variable \"%s\"", target
);
1829 /* A slightly faster and more convenient way to get
1830 (directory-file-name (expand-file-name FOO)). */
1833 expand_and_dir_to_file (filename
, defdir
)
1834 Lisp_Object filename
, defdir
;
1836 register Lisp_Object absname
;
1838 absname
= Fexpand_file_name (filename
, defdir
);
1840 /* Remove final slash, if any (unless this is the root dir).
1841 stat behaves differently depending! */
1842 if (SCHARS (absname
) > 1
1843 && IS_DIRECTORY_SEP (SREF (absname
, SBYTES (absname
) - 1))
1844 && !IS_DEVICE_SEP (SREF (absname
, SBYTES (absname
)-2)))
1845 /* We cannot take shortcuts; they might be wrong for magic file names. */
1846 absname
= Fdirectory_file_name (absname
);
1850 /* Signal an error if the file ABSNAME already exists.
1851 If INTERACTIVE is nonzero, ask the user whether to proceed,
1852 and bypass the error if the user says to go ahead.
1853 QUERYSTRING is a name for the action that is being considered
1856 *STATPTR is used to store the stat information if the file exists.
1857 If the file does not exist, STATPTR->st_mode is set to 0.
1858 If STATPTR is null, we don't store into it.
1860 If QUICK is nonzero, we ask for y or n, not yes or no. */
1863 barf_or_query_if_file_exists (absname
, querystring
, interactive
, statptr
, quick
)
1864 Lisp_Object absname
;
1865 unsigned char *querystring
;
1867 struct stat
*statptr
;
1870 register Lisp_Object tem
, encoded_filename
;
1871 struct stat statbuf
;
1872 struct gcpro gcpro1
;
1874 encoded_filename
= ENCODE_FILE (absname
);
1876 /* stat is a good way to tell whether the file exists,
1877 regardless of what access permissions it has. */
1878 if (lstat (SDATA (encoded_filename
), &statbuf
) >= 0)
1881 xsignal2 (Qfile_already_exists
,
1882 build_string ("File already exists"), absname
);
1884 tem
= format2 ("File %s already exists; %s anyway? ",
1885 absname
, build_string (querystring
));
1887 tem
= Fy_or_n_p (tem
);
1889 tem
= do_yes_or_no_p (tem
);
1892 xsignal2 (Qfile_already_exists
,
1893 build_string ("File already exists"), absname
);
1900 statptr
->st_mode
= 0;
1905 DEFUN ("copy-file", Fcopy_file
, Scopy_file
, 2, 5,
1906 "fCopy file: \nGCopy %s to file: \np\nP",
1907 doc
: /* Copy FILE to NEWNAME. Both args must be strings.
1908 If NEWNAME names a directory, copy FILE there.
1910 This function always sets the file modes of the output file to match
1913 The optional third argument OK-IF-ALREADY-EXISTS specifies what to do
1914 if file NEWNAME already exists. If OK-IF-ALREADY-EXISTS is nil, we
1915 signal a `file-already-exists' error without overwriting. If
1916 OK-IF-ALREADY-EXISTS is a number, we request confirmation from the user
1917 about overwriting; this is what happens in interactive use with M-x.
1918 Any other value for OK-IF-ALREADY-EXISTS means to overwrite the
1921 Fourth arg KEEP-TIME non-nil means give the output file the same
1922 last-modified time as the old one. (This works on only some systems.)
1924 A prefix arg makes KEEP-TIME non-nil.
1926 If PRESERVE-UID-GID is non-nil, we try to transfer the
1927 uid and gid of FILE to NEWNAME. */)
1928 (file
, newname
, ok_if_already_exists
, keep_time
, preserve_uid_gid
)
1929 Lisp_Object file
, newname
, ok_if_already_exists
, keep_time
;
1930 Lisp_Object preserve_uid_gid
;
1933 char buf
[16 * 1024];
1934 struct stat st
, out_st
;
1935 Lisp_Object handler
;
1936 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1937 int count
= SPECPDL_INDEX ();
1938 int input_file_statable_p
;
1939 Lisp_Object encoded_file
, encoded_newname
;
1941 encoded_file
= encoded_newname
= Qnil
;
1942 GCPRO4 (file
, newname
, encoded_file
, encoded_newname
);
1943 CHECK_STRING (file
);
1944 CHECK_STRING (newname
);
1946 if (!NILP (Ffile_directory_p (newname
)))
1947 newname
= Fexpand_file_name (Ffile_name_nondirectory (file
), newname
);
1949 newname
= Fexpand_file_name (newname
, Qnil
);
1951 file
= Fexpand_file_name (file
, Qnil
);
1953 /* If the input file name has special constructs in it,
1954 call the corresponding file handler. */
1955 handler
= Ffind_file_name_handler (file
, Qcopy_file
);
1956 /* Likewise for output file name. */
1958 handler
= Ffind_file_name_handler (newname
, Qcopy_file
);
1959 if (!NILP (handler
))
1960 RETURN_UNGCPRO (call6 (handler
, Qcopy_file
, file
, newname
,
1961 ok_if_already_exists
, keep_time
, preserve_uid_gid
));
1963 encoded_file
= ENCODE_FILE (file
);
1964 encoded_newname
= ENCODE_FILE (newname
);
1966 if (NILP (ok_if_already_exists
)
1967 || INTEGERP (ok_if_already_exists
))
1968 barf_or_query_if_file_exists (newname
, "copy to it",
1969 INTEGERP (ok_if_already_exists
), &out_st
, 0);
1970 else if (stat (SDATA (encoded_newname
), &out_st
) < 0)
1974 if (!CopyFile (SDATA (encoded_file
),
1975 SDATA (encoded_newname
),
1977 report_file_error ("Copying file", Fcons (file
, Fcons (newname
, Qnil
)));
1978 /* CopyFile retains the timestamp by default. */
1979 else if (NILP (keep_time
))
1985 EMACS_GET_TIME (now
);
1986 filename
= SDATA (encoded_newname
);
1988 /* Ensure file is writable while its modified time is set. */
1989 attributes
= GetFileAttributes (filename
);
1990 SetFileAttributes (filename
, attributes
& ~FILE_ATTRIBUTE_READONLY
);
1991 if (set_file_times (filename
, now
, now
))
1993 /* Restore original attributes. */
1994 SetFileAttributes (filename
, attributes
);
1995 xsignal2 (Qfile_date_error
,
1996 build_string ("Cannot set file date"), newname
);
1998 /* Restore original attributes. */
1999 SetFileAttributes (filename
, attributes
);
2001 #else /* not WINDOWSNT */
2003 ifd
= emacs_open (SDATA (encoded_file
), O_RDONLY
, 0);
2007 report_file_error ("Opening input file", Fcons (file
, Qnil
));
2009 record_unwind_protect (close_file_unwind
, make_number (ifd
));
2011 /* We can only copy regular files and symbolic links. Other files are not
2013 input_file_statable_p
= (fstat (ifd
, &st
) >= 0);
2015 #if !defined (MSDOS) || __DJGPP__ > 1
2016 if (out_st
.st_mode
!= 0
2017 && st
.st_dev
== out_st
.st_dev
&& st
.st_ino
== out_st
.st_ino
)
2020 report_file_error ("Input and output files are the same",
2021 Fcons (file
, Fcons (newname
, Qnil
)));
2025 #if defined (S_ISREG) && defined (S_ISLNK)
2026 if (input_file_statable_p
)
2028 if (!(S_ISREG (st
.st_mode
)) && !(S_ISLNK (st
.st_mode
)))
2030 #if defined (EISDIR)
2031 /* Get a better looking error message. */
2034 report_file_error ("Non-regular file", Fcons (file
, Qnil
));
2037 #endif /* S_ISREG && S_ISLNK */
2040 /* System's default file type was set to binary by _fmode in emacs.c. */
2041 ofd
= emacs_open (SDATA (encoded_newname
),
2042 O_WRONLY
| O_TRUNC
| O_CREAT
2043 | (NILP (ok_if_already_exists
) ? O_EXCL
: 0),
2044 S_IREAD
| S_IWRITE
);
2045 #else /* not MSDOS */
2046 ofd
= emacs_open (SDATA (encoded_newname
),
2047 O_WRONLY
| O_TRUNC
| O_CREAT
2048 | (NILP (ok_if_already_exists
) ? O_EXCL
: 0),
2050 #endif /* not MSDOS */
2052 report_file_error ("Opening output file", Fcons (newname
, Qnil
));
2054 record_unwind_protect (close_file_unwind
, make_number (ofd
));
2058 while ((n
= emacs_read (ifd
, buf
, sizeof buf
)) > 0)
2059 if (emacs_write (ofd
, buf
, n
) != n
)
2060 report_file_error ("I/O error", Fcons (newname
, Qnil
));
2064 /* Preserve the original file modes, and if requested, also its
2066 if (input_file_statable_p
)
2068 if (! NILP (preserve_uid_gid
))
2069 fchown (ofd
, st
.st_uid
, st
.st_gid
);
2070 fchmod (ofd
, st
.st_mode
& 07777);
2072 #endif /* not MSDOS */
2074 /* Closing the output clobbers the file times on some systems. */
2075 if (emacs_close (ofd
) < 0)
2076 report_file_error ("I/O error", Fcons (newname
, Qnil
));
2078 if (input_file_statable_p
)
2080 if (!NILP (keep_time
))
2082 EMACS_TIME atime
, mtime
;
2083 EMACS_SET_SECS_USECS (atime
, st
.st_atime
, 0);
2084 EMACS_SET_SECS_USECS (mtime
, st
.st_mtime
, 0);
2085 if (set_file_times (SDATA (encoded_newname
),
2087 xsignal2 (Qfile_date_error
,
2088 build_string ("Cannot set file date"), newname
);
2094 #if defined (__DJGPP__) && __DJGPP__ > 1
2095 if (input_file_statable_p
)
2097 /* In DJGPP v2.0 and later, fstat usually returns true file mode bits,
2098 and if it can't, it tells so. Otherwise, under MSDOS we usually
2099 get only the READ bit, which will make the copied file read-only,
2100 so it's better not to chmod at all. */
2101 if ((_djstat_flags
& _STFAIL_WRITEBIT
) == 0)
2102 chmod (SDATA (encoded_newname
), st
.st_mode
& 07777);
2104 #endif /* DJGPP version 2 or newer */
2105 #endif /* not WINDOWSNT */
2107 /* Discard the unwind protects. */
2108 specpdl_ptr
= specpdl
+ count
;
2114 DEFUN ("make-directory-internal", Fmake_directory_internal
,
2115 Smake_directory_internal
, 1, 1, 0,
2116 doc
: /* Create a new directory named DIRECTORY. */)
2118 Lisp_Object directory
;
2120 const unsigned char *dir
;
2121 Lisp_Object handler
;
2122 Lisp_Object encoded_dir
;
2124 CHECK_STRING (directory
);
2125 directory
= Fexpand_file_name (directory
, Qnil
);
2127 handler
= Ffind_file_name_handler (directory
, Qmake_directory_internal
);
2128 if (!NILP (handler
))
2129 return call2 (handler
, Qmake_directory_internal
, directory
);
2131 encoded_dir
= ENCODE_FILE (directory
);
2133 dir
= SDATA (encoded_dir
);
2136 if (mkdir (dir
) != 0)
2138 if (mkdir (dir
, 0777) != 0)
2140 report_file_error ("Creating directory", list1 (directory
));
2145 DEFUN ("delete-directory-internal", Fdelete_directory_internal
,
2146 Sdelete_directory_internal
, 1, 1, 0,
2147 doc
: /* Delete the directory named DIRECTORY. Does not follow symlinks. */)
2149 Lisp_Object directory
;
2151 const unsigned char *dir
;
2152 Lisp_Object handler
;
2153 Lisp_Object encoded_dir
;
2155 CHECK_STRING (directory
);
2156 directory
= Fdirectory_file_name (Fexpand_file_name (directory
, Qnil
));
2158 if (delete_by_moving_to_trash
)
2159 return call1 (Qmove_file_to_trash
, directory
);
2161 encoded_dir
= ENCODE_FILE (directory
);
2163 dir
= SDATA (encoded_dir
);
2165 if (rmdir (dir
) != 0)
2166 report_file_error ("Removing directory", list1 (directory
));
2171 DEFUN ("delete-file", Fdelete_file
, Sdelete_file
, 1, 1, "fDelete file: ",
2172 doc
: /* Delete file named FILENAME. If it is a symlink, remove the symlink.
2173 If file has multiple names, it continues to exist with the other names. */)
2175 Lisp_Object filename
;
2177 Lisp_Object handler
;
2178 Lisp_Object encoded_file
;
2179 struct gcpro gcpro1
;
2182 if (!NILP (Ffile_directory_p (filename
))
2183 && NILP (Ffile_symlink_p (filename
)))
2184 xsignal2 (Qfile_error
,
2185 build_string ("Removing old name: is a directory"),
2188 filename
= Fexpand_file_name (filename
, Qnil
);
2190 handler
= Ffind_file_name_handler (filename
, Qdelete_file
);
2191 if (!NILP (handler
))
2192 return call2 (handler
, Qdelete_file
, filename
);
2194 if (delete_by_moving_to_trash
)
2195 return call1 (Qmove_file_to_trash
, filename
);
2197 encoded_file
= ENCODE_FILE (filename
);
2199 if (0 > unlink (SDATA (encoded_file
)))
2200 report_file_error ("Removing old name", list1 (filename
));
2205 internal_delete_file_1 (ignore
)
2211 /* Delete file FILENAME, returning 1 if successful and 0 if failed. */
2214 internal_delete_file (filename
)
2215 Lisp_Object filename
;
2218 tem
= internal_condition_case_1 (Fdelete_file
, filename
,
2219 Qt
, internal_delete_file_1
);
2223 DEFUN ("rename-file", Frename_file
, Srename_file
, 2, 3,
2224 "fRename file: \nGRename %s to file: \np",
2225 doc
: /* Rename FILE as NEWNAME. Both args must be strings.
2226 If file has names other than FILE, it continues to have those names.
2227 Signals a `file-already-exists' error if a file NEWNAME already exists
2228 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
2229 A number as third arg means request confirmation if NEWNAME already exists.
2230 This is what happens in interactive use with M-x. */)
2231 (file
, newname
, ok_if_already_exists
)
2232 Lisp_Object file
, newname
, ok_if_already_exists
;
2234 Lisp_Object handler
;
2235 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2236 Lisp_Object encoded_file
, encoded_newname
, symlink_target
;
2238 symlink_target
= encoded_file
= encoded_newname
= Qnil
;
2239 GCPRO5 (file
, newname
, encoded_file
, encoded_newname
, symlink_target
);
2240 CHECK_STRING (file
);
2241 CHECK_STRING (newname
);
2242 file
= Fexpand_file_name (file
, Qnil
);
2244 if ((!NILP (Ffile_directory_p (newname
)))
2246 /* If the file names are identical but for the case,
2247 don't attempt to move directory to itself. */
2248 && (NILP (Fstring_equal (Fdowncase (file
), Fdowncase (newname
))))
2252 Lisp_Object fname
= NILP (Ffile_directory_p (file
))
2253 ? file
: Fdirectory_file_name (file
);
2254 newname
= Fexpand_file_name (Ffile_name_nondirectory (fname
), newname
);
2257 newname
= Fexpand_file_name (newname
, Qnil
);
2259 /* If the file name has special constructs in it,
2260 call the corresponding file handler. */
2261 handler
= Ffind_file_name_handler (file
, Qrename_file
);
2263 handler
= Ffind_file_name_handler (newname
, Qrename_file
);
2264 if (!NILP (handler
))
2265 RETURN_UNGCPRO (call4 (handler
, Qrename_file
,
2266 file
, newname
, ok_if_already_exists
));
2268 encoded_file
= ENCODE_FILE (file
);
2269 encoded_newname
= ENCODE_FILE (newname
);
2272 /* If the file names are identical but for the case, don't ask for
2273 confirmation: they simply want to change the letter-case of the
2275 if (NILP (Fstring_equal (Fdowncase (file
), Fdowncase (newname
))))
2277 if (NILP (ok_if_already_exists
)
2278 || INTEGERP (ok_if_already_exists
))
2279 barf_or_query_if_file_exists (newname
, "rename to it",
2280 INTEGERP (ok_if_already_exists
), 0, 0);
2281 if (0 > rename (SDATA (encoded_file
), SDATA (encoded_newname
)))
2287 symlink_target
= Ffile_symlink_p (file
);
2288 if (! NILP (symlink_target
))
2289 Fmake_symbolic_link (symlink_target
, newname
,
2290 NILP (ok_if_already_exists
) ? Qnil
: Qt
);
2293 if (!NILP (Ffile_directory_p (file
)))
2294 call4 (Qcopy_directory
, file
, newname
, Qt
, Qnil
);
2296 /* We have already prompted if it was an integer, so don't
2297 have copy-file prompt again. */
2298 Fcopy_file (file
, newname
,
2299 NILP (ok_if_already_exists
) ? Qnil
: Qt
,
2302 count
= SPECPDL_INDEX ();
2303 specbind (Qdelete_by_moving_to_trash
, Qnil
);
2305 if (!NILP (Ffile_directory_p (file
))
2307 && NILP (symlink_target
)
2310 call2 (Qdelete_directory
, file
, Qt
);
2312 Fdelete_file (file
);
2313 unbind_to (count
, Qnil
);
2316 report_file_error ("Renaming", list2 (file
, newname
));
2322 DEFUN ("add-name-to-file", Fadd_name_to_file
, Sadd_name_to_file
, 2, 3,
2323 "fAdd name to file: \nGName to add to %s: \np",
2324 doc
: /* Give FILE additional name NEWNAME. Both args must be strings.
2325 Signals a `file-already-exists' error if a file NEWNAME already exists
2326 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
2327 A number as third arg means request confirmation if NEWNAME already exists.
2328 This is what happens in interactive use with M-x. */)
2329 (file
, newname
, ok_if_already_exists
)
2330 Lisp_Object file
, newname
, ok_if_already_exists
;
2332 Lisp_Object handler
;
2333 Lisp_Object encoded_file
, encoded_newname
;
2334 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2336 GCPRO4 (file
, newname
, encoded_file
, encoded_newname
);
2337 encoded_file
= encoded_newname
= Qnil
;
2338 CHECK_STRING (file
);
2339 CHECK_STRING (newname
);
2340 file
= Fexpand_file_name (file
, Qnil
);
2342 if (!NILP (Ffile_directory_p (newname
)))
2343 newname
= Fexpand_file_name (Ffile_name_nondirectory (file
), newname
);
2345 newname
= Fexpand_file_name (newname
, Qnil
);
2347 /* If the file name has special constructs in it,
2348 call the corresponding file handler. */
2349 handler
= Ffind_file_name_handler (file
, Qadd_name_to_file
);
2350 if (!NILP (handler
))
2351 RETURN_UNGCPRO (call4 (handler
, Qadd_name_to_file
, file
,
2352 newname
, ok_if_already_exists
));
2354 /* If the new name has special constructs in it,
2355 call the corresponding file handler. */
2356 handler
= Ffind_file_name_handler (newname
, Qadd_name_to_file
);
2357 if (!NILP (handler
))
2358 RETURN_UNGCPRO (call4 (handler
, Qadd_name_to_file
, file
,
2359 newname
, ok_if_already_exists
));
2361 encoded_file
= ENCODE_FILE (file
);
2362 encoded_newname
= ENCODE_FILE (newname
);
2364 if (NILP (ok_if_already_exists
)
2365 || INTEGERP (ok_if_already_exists
))
2366 barf_or_query_if_file_exists (newname
, "make it a new name",
2367 INTEGERP (ok_if_already_exists
), 0, 0);
2369 unlink (SDATA (newname
));
2370 if (0 > link (SDATA (encoded_file
), SDATA (encoded_newname
)))
2371 report_file_error ("Adding new name", list2 (file
, newname
));
2377 DEFUN ("make-symbolic-link", Fmake_symbolic_link
, Smake_symbolic_link
, 2, 3,
2378 "FMake symbolic link to file: \nGMake symbolic link to file %s: \np",
2379 doc
: /* Make a symbolic link to FILENAME, named LINKNAME.
2380 Both args must be strings.
2381 Signals a `file-already-exists' error if a file LINKNAME already exists
2382 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
2383 A number as third arg means request confirmation if LINKNAME already exists.
2384 This happens for interactive use with M-x. */)
2385 (filename
, linkname
, ok_if_already_exists
)
2386 Lisp_Object filename
, linkname
, ok_if_already_exists
;
2388 Lisp_Object handler
;
2389 Lisp_Object encoded_filename
, encoded_linkname
;
2390 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2392 GCPRO4 (filename
, linkname
, encoded_filename
, encoded_linkname
);
2393 encoded_filename
= encoded_linkname
= Qnil
;
2394 CHECK_STRING (filename
);
2395 CHECK_STRING (linkname
);
2396 /* If the link target has a ~, we must expand it to get
2397 a truly valid file name. Otherwise, do not expand;
2398 we want to permit links to relative file names. */
2399 if (SREF (filename
, 0) == '~')
2400 filename
= Fexpand_file_name (filename
, Qnil
);
2402 if (!NILP (Ffile_directory_p (linkname
)))
2403 linkname
= Fexpand_file_name (Ffile_name_nondirectory (filename
), linkname
);
2405 linkname
= Fexpand_file_name (linkname
, Qnil
);
2407 /* If the file name has special constructs in it,
2408 call the corresponding file handler. */
2409 handler
= Ffind_file_name_handler (filename
, Qmake_symbolic_link
);
2410 if (!NILP (handler
))
2411 RETURN_UNGCPRO (call4 (handler
, Qmake_symbolic_link
, filename
,
2412 linkname
, ok_if_already_exists
));
2414 /* If the new link name has special constructs in it,
2415 call the corresponding file handler. */
2416 handler
= Ffind_file_name_handler (linkname
, Qmake_symbolic_link
);
2417 if (!NILP (handler
))
2418 RETURN_UNGCPRO (call4 (handler
, Qmake_symbolic_link
, filename
,
2419 linkname
, ok_if_already_exists
));
2422 encoded_filename
= ENCODE_FILE (filename
);
2423 encoded_linkname
= ENCODE_FILE (linkname
);
2425 if (NILP (ok_if_already_exists
)
2426 || INTEGERP (ok_if_already_exists
))
2427 barf_or_query_if_file_exists (linkname
, "make it a link",
2428 INTEGERP (ok_if_already_exists
), 0, 0);
2429 if (0 > symlink (SDATA (encoded_filename
),
2430 SDATA (encoded_linkname
)))
2432 /* If we didn't complain already, silently delete existing file. */
2433 if (errno
== EEXIST
)
2435 unlink (SDATA (encoded_linkname
));
2436 if (0 <= symlink (SDATA (encoded_filename
),
2437 SDATA (encoded_linkname
)))
2444 report_file_error ("Making symbolic link", list2 (filename
, linkname
));
2451 xsignal1 (Qfile_error
, build_string ("Symbolic links are not supported"));
2453 #endif /* S_IFLNK */
2457 DEFUN ("file-name-absolute-p", Ffile_name_absolute_p
, Sfile_name_absolute_p
,
2459 doc
: /* Return t if file FILENAME specifies an absolute file name.
2460 On Unix, this is a name starting with a `/' or a `~'. */)
2462 Lisp_Object filename
;
2464 CHECK_STRING (filename
);
2465 return file_name_absolute_p (SDATA (filename
)) ? Qt
: Qnil
;
2468 /* Return nonzero if file FILENAME exists and can be executed. */
2471 check_executable (filename
)
2475 int len
= strlen (filename
);
2478 if (stat (filename
, &st
) < 0)
2480 #if defined (WINDOWSNT) || (defined (MSDOS) && __DJGPP__ > 1)
2481 return ((st
.st_mode
& S_IEXEC
) != 0);
2483 return (S_ISREG (st
.st_mode
)
2485 && (xstrcasecmp ((suffix
= filename
+ len
-4), ".com") == 0
2486 || xstrcasecmp (suffix
, ".exe") == 0
2487 || xstrcasecmp (suffix
, ".bat") == 0)
2488 || (st
.st_mode
& S_IFMT
) == S_IFDIR
);
2489 #endif /* not WINDOWSNT */
2490 #else /* not DOS_NT */
2491 #ifdef HAVE_EUIDACCESS
2492 return (euidaccess (filename
, 1) >= 0);
2494 /* Access isn't quite right because it uses the real uid
2495 and we really want to test with the effective uid.
2496 But Unix doesn't give us a right way to do it. */
2497 return (access (filename
, 1) >= 0);
2499 #endif /* not DOS_NT */
2502 /* Return nonzero if file FILENAME exists and can be written. */
2505 check_writable (filename
)
2510 if (stat (filename
, &st
) < 0)
2512 return (st
.st_mode
& S_IWRITE
|| (st
.st_mode
& S_IFMT
) == S_IFDIR
);
2513 #else /* not MSDOS */
2514 #ifdef HAVE_EUIDACCESS
2515 return (euidaccess (filename
, 2) >= 0);
2517 /* Access isn't quite right because it uses the real uid
2518 and we really want to test with the effective uid.
2519 But Unix doesn't give us a right way to do it.
2520 Opening with O_WRONLY could work for an ordinary file,
2521 but would lose for directories. */
2522 return (access (filename
, 2) >= 0);
2524 #endif /* not MSDOS */
2527 DEFUN ("file-exists-p", Ffile_exists_p
, Sfile_exists_p
, 1, 1, 0,
2528 doc
: /* Return t if file FILENAME exists (whether or not you can read it.)
2529 See also `file-readable-p' and `file-attributes'.
2530 This returns nil for a symlink to a nonexistent file.
2531 Use `file-symlink-p' to test for such links. */)
2533 Lisp_Object filename
;
2535 Lisp_Object absname
;
2536 Lisp_Object handler
;
2537 struct stat statbuf
;
2539 CHECK_STRING (filename
);
2540 absname
= Fexpand_file_name (filename
, Qnil
);
2542 /* If the file name has special constructs in it,
2543 call the corresponding file handler. */
2544 handler
= Ffind_file_name_handler (absname
, Qfile_exists_p
);
2545 if (!NILP (handler
))
2546 return call2 (handler
, Qfile_exists_p
, absname
);
2548 absname
= ENCODE_FILE (absname
);
2550 return (stat (SDATA (absname
), &statbuf
) >= 0) ? Qt
: Qnil
;
2553 DEFUN ("file-executable-p", Ffile_executable_p
, Sfile_executable_p
, 1, 1, 0,
2554 doc
: /* Return t if FILENAME can be executed by you.
2555 For a directory, this means you can access files in that directory. */)
2557 Lisp_Object filename
;
2559 Lisp_Object absname
;
2560 Lisp_Object handler
;
2562 CHECK_STRING (filename
);
2563 absname
= Fexpand_file_name (filename
, Qnil
);
2565 /* If the file name has special constructs in it,
2566 call the corresponding file handler. */
2567 handler
= Ffind_file_name_handler (absname
, Qfile_executable_p
);
2568 if (!NILP (handler
))
2569 return call2 (handler
, Qfile_executable_p
, absname
);
2571 absname
= ENCODE_FILE (absname
);
2573 return (check_executable (SDATA (absname
)) ? Qt
: Qnil
);
2576 DEFUN ("file-readable-p", Ffile_readable_p
, Sfile_readable_p
, 1, 1, 0,
2577 doc
: /* Return t if file FILENAME exists and you can read it.
2578 See also `file-exists-p' and `file-attributes'. */)
2580 Lisp_Object filename
;
2582 Lisp_Object absname
;
2583 Lisp_Object handler
;
2586 struct stat statbuf
;
2588 CHECK_STRING (filename
);
2589 absname
= Fexpand_file_name (filename
, Qnil
);
2591 /* If the file name has special constructs in it,
2592 call the corresponding file handler. */
2593 handler
= Ffind_file_name_handler (absname
, Qfile_readable_p
);
2594 if (!NILP (handler
))
2595 return call2 (handler
, Qfile_readable_p
, absname
);
2597 absname
= ENCODE_FILE (absname
);
2599 #if defined(DOS_NT) || defined(macintosh)
2600 /* Under MS-DOS, Windows, and Macintosh, open does not work for
2602 if (access (SDATA (absname
), 0) == 0)
2605 #else /* not DOS_NT and not macintosh */
2607 #if defined (S_ISFIFO) && defined (O_NONBLOCK)
2608 /* Opening a fifo without O_NONBLOCK can wait.
2609 We don't want to wait. But we don't want to mess wth O_NONBLOCK
2610 except in the case of a fifo, on a system which handles it. */
2611 desc
= stat (SDATA (absname
), &statbuf
);
2614 if (S_ISFIFO (statbuf
.st_mode
))
2615 flags
|= O_NONBLOCK
;
2617 desc
= emacs_open (SDATA (absname
), flags
, 0);
2622 #endif /* not DOS_NT and not macintosh */
2625 /* Having this before file-symlink-p mysteriously caused it to be forgotten
2627 DEFUN ("file-writable-p", Ffile_writable_p
, Sfile_writable_p
, 1, 1, 0,
2628 doc
: /* Return t if file FILENAME can be written or created by you. */)
2630 Lisp_Object filename
;
2632 Lisp_Object absname
, dir
, encoded
;
2633 Lisp_Object handler
;
2634 struct stat statbuf
;
2636 CHECK_STRING (filename
);
2637 absname
= Fexpand_file_name (filename
, Qnil
);
2639 /* If the file name has special constructs in it,
2640 call the corresponding file handler. */
2641 handler
= Ffind_file_name_handler (absname
, Qfile_writable_p
);
2642 if (!NILP (handler
))
2643 return call2 (handler
, Qfile_writable_p
, absname
);
2645 encoded
= ENCODE_FILE (absname
);
2646 if (stat (SDATA (encoded
), &statbuf
) >= 0)
2647 return (check_writable (SDATA (encoded
))
2650 dir
= Ffile_name_directory (absname
);
2653 dir
= Fdirectory_file_name (dir
);
2656 dir
= ENCODE_FILE (dir
);
2658 /* The read-only attribute of the parent directory doesn't affect
2659 whether a file or directory can be created within it. Some day we
2660 should check ACLs though, which do affect this. */
2661 if (stat (SDATA (dir
), &statbuf
) < 0)
2663 return (statbuf
.st_mode
& S_IFMT
) == S_IFDIR
? Qt
: Qnil
;
2665 return (check_writable (!NILP (dir
) ? (char *) SDATA (dir
) : "")
2670 DEFUN ("access-file", Faccess_file
, Saccess_file
, 2, 2, 0,
2671 doc
: /* Access file FILENAME, and get an error if that does not work.
2672 The second argument STRING is used in the error message.
2673 If there is no error, returns nil. */)
2675 Lisp_Object filename
, string
;
2677 Lisp_Object handler
, encoded_filename
, absname
;
2680 CHECK_STRING (filename
);
2681 absname
= Fexpand_file_name (filename
, Qnil
);
2683 CHECK_STRING (string
);
2685 /* If the file name has special constructs in it,
2686 call the corresponding file handler. */
2687 handler
= Ffind_file_name_handler (absname
, Qaccess_file
);
2688 if (!NILP (handler
))
2689 return call3 (handler
, Qaccess_file
, absname
, string
);
2691 encoded_filename
= ENCODE_FILE (absname
);
2693 fd
= emacs_open (SDATA (encoded_filename
), O_RDONLY
, 0);
2695 report_file_error (SDATA (string
), Fcons (filename
, Qnil
));
2701 DEFUN ("file-symlink-p", Ffile_symlink_p
, Sfile_symlink_p
, 1, 1, 0,
2702 doc
: /* Return non-nil if file FILENAME is the name of a symbolic link.
2703 The value is the link target, as a string.
2704 Otherwise it returns nil.
2706 This function returns t when given the name of a symlink that
2707 points to a nonexistent file. */)
2709 Lisp_Object filename
;
2711 Lisp_Object handler
;
2713 CHECK_STRING (filename
);
2714 filename
= Fexpand_file_name (filename
, Qnil
);
2716 /* If the file name has special constructs in it,
2717 call the corresponding file handler. */
2718 handler
= Ffind_file_name_handler (filename
, Qfile_symlink_p
);
2719 if (!NILP (handler
))
2720 return call2 (handler
, Qfile_symlink_p
, filename
);
2729 filename
= ENCODE_FILE (filename
);
2736 buf
= (char *) xrealloc (buf
, bufsize
);
2737 bzero (buf
, bufsize
);
2740 valsize
= readlink (SDATA (filename
), buf
, bufsize
);
2744 /* HP-UX reports ERANGE if buffer is too small. */
2745 if (errno
== ERANGE
)
2755 while (valsize
>= bufsize
);
2757 val
= make_string (buf
, valsize
);
2758 if (buf
[0] == '/' && index (buf
, ':'))
2759 val
= concat2 (build_string ("/:"), val
);
2761 val
= DECODE_FILE (val
);
2764 #else /* not S_IFLNK */
2766 #endif /* not S_IFLNK */
2769 DEFUN ("file-directory-p", Ffile_directory_p
, Sfile_directory_p
, 1, 1, 0,
2770 doc
: /* Return t if FILENAME names an existing directory.
2771 Symbolic links to directories count as directories.
2772 See `file-symlink-p' to distinguish symlinks. */)
2774 Lisp_Object filename
;
2776 register Lisp_Object absname
;
2778 Lisp_Object handler
;
2780 absname
= expand_and_dir_to_file (filename
, current_buffer
->directory
);
2782 /* If the file name has special constructs in it,
2783 call the corresponding file handler. */
2784 handler
= Ffind_file_name_handler (absname
, Qfile_directory_p
);
2785 if (!NILP (handler
))
2786 return call2 (handler
, Qfile_directory_p
, absname
);
2788 absname
= ENCODE_FILE (absname
);
2790 if (stat (SDATA (absname
), &st
) < 0)
2792 return (st
.st_mode
& S_IFMT
) == S_IFDIR
? Qt
: Qnil
;
2795 DEFUN ("file-accessible-directory-p", Ffile_accessible_directory_p
, Sfile_accessible_directory_p
, 1, 1, 0,
2796 doc
: /* Return t if file FILENAME names a directory you can open.
2797 For the value to be t, FILENAME must specify the name of a directory as a file,
2798 and the directory must allow you to open files in it. In order to use a
2799 directory as a buffer's current directory, this predicate must return true.
2800 A directory name spec may be given instead; then the value is t
2801 if the directory so specified exists and really is a readable and
2802 searchable directory. */)
2804 Lisp_Object filename
;
2806 Lisp_Object handler
;
2808 struct gcpro gcpro1
;
2810 /* If the file name has special constructs in it,
2811 call the corresponding file handler. */
2812 handler
= Ffind_file_name_handler (filename
, Qfile_accessible_directory_p
);
2813 if (!NILP (handler
))
2814 return call2 (handler
, Qfile_accessible_directory_p
, filename
);
2817 tem
= (NILP (Ffile_directory_p (filename
))
2818 || NILP (Ffile_executable_p (filename
)));
2820 return tem
? Qnil
: Qt
;
2823 DEFUN ("file-regular-p", Ffile_regular_p
, Sfile_regular_p
, 1, 1, 0,
2824 doc
: /* Return t if FILENAME names a regular file.
2825 This is the sort of file that holds an ordinary stream of data bytes.
2826 Symbolic links to regular files count as regular files.
2827 See `file-symlink-p' to distinguish symlinks. */)
2829 Lisp_Object filename
;
2831 register Lisp_Object absname
;
2833 Lisp_Object handler
;
2835 absname
= expand_and_dir_to_file (filename
, current_buffer
->directory
);
2837 /* If the file name has special constructs in it,
2838 call the corresponding file handler. */
2839 handler
= Ffind_file_name_handler (absname
, Qfile_regular_p
);
2840 if (!NILP (handler
))
2841 return call2 (handler
, Qfile_regular_p
, absname
);
2843 absname
= ENCODE_FILE (absname
);
2848 Lisp_Object tem
= Vw32_get_true_file_attributes
;
2850 /* Tell stat to use expensive method to get accurate info. */
2851 Vw32_get_true_file_attributes
= Qt
;
2852 result
= stat (SDATA (absname
), &st
);
2853 Vw32_get_true_file_attributes
= tem
;
2857 return (st
.st_mode
& S_IFMT
) == S_IFREG
? Qt
: Qnil
;
2860 if (stat (SDATA (absname
), &st
) < 0)
2862 return (st
.st_mode
& S_IFMT
) == S_IFREG
? Qt
: Qnil
;
2866 DEFUN ("file-modes", Ffile_modes
, Sfile_modes
, 1, 1, 0,
2867 doc
: /* Return mode bits of file named FILENAME, as an integer.
2868 Return nil, if file does not exist or is not accessible. */)
2870 Lisp_Object filename
;
2872 Lisp_Object absname
;
2874 Lisp_Object handler
;
2876 absname
= expand_and_dir_to_file (filename
, current_buffer
->directory
);
2878 /* If the file name has special constructs in it,
2879 call the corresponding file handler. */
2880 handler
= Ffind_file_name_handler (absname
, Qfile_modes
);
2881 if (!NILP (handler
))
2882 return call2 (handler
, Qfile_modes
, absname
);
2884 absname
= ENCODE_FILE (absname
);
2886 if (stat (SDATA (absname
), &st
) < 0)
2888 #if defined (MSDOS) && __DJGPP__ < 2
2889 if (check_executable (SDATA (absname
)))
2890 st
.st_mode
|= S_IEXEC
;
2891 #endif /* MSDOS && __DJGPP__ < 2 */
2893 return make_number (st
.st_mode
& 07777);
2896 DEFUN ("set-file-modes", Fset_file_modes
, Sset_file_modes
, 2, 2,
2897 "(let ((file (read-file-name \"File: \"))) \
2898 (list file (read-file-modes nil file)))",
2899 doc
: /* Set mode bits of file named FILENAME to MODE (an integer).
2900 Only the 12 low bits of MODE are used.
2902 Interactively, mode bits are read by `read-file-modes', which accepts
2903 symbolic notation, like the `chmod' command from GNU Coreutils. */)
2905 Lisp_Object filename
, mode
;
2907 Lisp_Object absname
, encoded_absname
;
2908 Lisp_Object handler
;
2910 absname
= Fexpand_file_name (filename
, current_buffer
->directory
);
2911 CHECK_NUMBER (mode
);
2913 /* If the file name has special constructs in it,
2914 call the corresponding file handler. */
2915 handler
= Ffind_file_name_handler (absname
, Qset_file_modes
);
2916 if (!NILP (handler
))
2917 return call3 (handler
, Qset_file_modes
, absname
, mode
);
2919 encoded_absname
= ENCODE_FILE (absname
);
2921 if (chmod (SDATA (encoded_absname
), XINT (mode
)) < 0)
2922 report_file_error ("Doing chmod", Fcons (absname
, Qnil
));
2927 DEFUN ("set-default-file-modes", Fset_default_file_modes
, Sset_default_file_modes
, 1, 1, 0,
2928 doc
: /* Set the file permission bits for newly created files.
2929 The argument MODE should be an integer; only the low 9 bits are used.
2930 This setting is inherited by subprocesses. */)
2934 CHECK_NUMBER (mode
);
2936 umask ((~ XINT (mode
)) & 0777);
2941 DEFUN ("default-file-modes", Fdefault_file_modes
, Sdefault_file_modes
, 0, 0, 0,
2942 doc
: /* Return the default file protection for created files.
2943 The value is an integer. */)
2949 realmask
= umask (0);
2952 XSETINT (value
, (~ realmask
) & 0777);
2956 extern int lisp_time_argument
P_ ((Lisp_Object
, time_t *, int *));
2958 DEFUN ("set-file-times", Fset_file_times
, Sset_file_times
, 1, 2, 0,
2959 doc
: /* Set times of file FILENAME to TIME.
2960 Set both access and modification times.
2961 Return t on success, else nil.
2962 Use the current time if TIME is nil. TIME is in the format of
2965 Lisp_Object filename
, time
;
2967 Lisp_Object absname
, encoded_absname
;
2968 Lisp_Object handler
;
2972 if (! lisp_time_argument (time
, &sec
, &usec
))
2973 error ("Invalid time specification");
2975 absname
= Fexpand_file_name (filename
, current_buffer
->directory
);
2977 /* If the file name has special constructs in it,
2978 call the corresponding file handler. */
2979 handler
= Ffind_file_name_handler (absname
, Qset_file_times
);
2980 if (!NILP (handler
))
2981 return call3 (handler
, Qset_file_times
, absname
, time
);
2983 encoded_absname
= ENCODE_FILE (absname
);
2988 EMACS_SET_SECS (t
, sec
);
2989 EMACS_SET_USECS (t
, usec
);
2991 if (set_file_times (SDATA (encoded_absname
), t
, t
))
2996 /* Setting times on a directory always fails. */
2997 if (stat (SDATA (encoded_absname
), &st
) == 0
2998 && (st
.st_mode
& S_IFMT
) == S_IFDIR
)
3001 report_file_error ("Setting file times", Fcons (absname
, Qnil
));
3010 DEFUN ("unix-sync", Funix_sync
, Sunix_sync
, 0, 0, "",
3011 doc
: /* Tell Unix to finish all pending disk updates. */)
3018 #endif /* HAVE_SYNC */
3020 DEFUN ("file-newer-than-file-p", Ffile_newer_than_file_p
, Sfile_newer_than_file_p
, 2, 2, 0,
3021 doc
: /* Return t if file FILE1 is newer than file FILE2.
3022 If FILE1 does not exist, the answer is nil;
3023 otherwise, if FILE2 does not exist, the answer is t. */)
3025 Lisp_Object file1
, file2
;
3027 Lisp_Object absname1
, absname2
;
3030 Lisp_Object handler
;
3031 struct gcpro gcpro1
, gcpro2
;
3033 CHECK_STRING (file1
);
3034 CHECK_STRING (file2
);
3037 GCPRO2 (absname1
, file2
);
3038 absname1
= expand_and_dir_to_file (file1
, current_buffer
->directory
);
3039 absname2
= expand_and_dir_to_file (file2
, current_buffer
->directory
);
3042 /* If the file name has special constructs in it,
3043 call the corresponding file handler. */
3044 handler
= Ffind_file_name_handler (absname1
, Qfile_newer_than_file_p
);
3046 handler
= Ffind_file_name_handler (absname2
, Qfile_newer_than_file_p
);
3047 if (!NILP (handler
))
3048 return call3 (handler
, Qfile_newer_than_file_p
, absname1
, absname2
);
3050 GCPRO2 (absname1
, absname2
);
3051 absname1
= ENCODE_FILE (absname1
);
3052 absname2
= ENCODE_FILE (absname2
);
3055 if (stat (SDATA (absname1
), &st
) < 0)
3058 mtime1
= st
.st_mtime
;
3060 if (stat (SDATA (absname2
), &st
) < 0)
3063 return (mtime1
> st
.st_mtime
) ? Qt
: Qnil
;
3067 Lisp_Object Qfind_buffer_file_type
;
3070 #ifndef READ_BUF_SIZE
3071 #define READ_BUF_SIZE (64 << 10)
3074 /* This function is called after Lisp functions to decide a coding
3075 system are called, or when they cause an error. Before they are
3076 called, the current buffer is set unibyte and it contains only a
3077 newly inserted text (thus the buffer was empty before the
3080 The functions may set markers, overlays, text properties, or even
3081 alter the buffer contents, change the current buffer.
3083 Here, we reset all those changes by:
3084 o set back the current buffer.
3085 o move all markers and overlays to BEG.
3086 o remove all text properties.
3087 o set back the buffer multibyteness. */
3090 decide_coding_unwind (unwind_data
)
3091 Lisp_Object unwind_data
;
3093 Lisp_Object multibyte
, undo_list
, buffer
;
3095 multibyte
= XCAR (unwind_data
);
3096 unwind_data
= XCDR (unwind_data
);
3097 undo_list
= XCAR (unwind_data
);
3098 buffer
= XCDR (unwind_data
);
3100 if (current_buffer
!= XBUFFER (buffer
))
3101 set_buffer_internal (XBUFFER (buffer
));
3102 adjust_markers_for_delete (BEG
, BEG_BYTE
, Z
, Z_BYTE
);
3103 adjust_overlays_for_delete (BEG
, Z
- BEG
);
3104 BUF_INTERVALS (current_buffer
) = 0;
3105 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
3107 /* Now we are safe to change the buffer's multibyteness directly. */
3108 current_buffer
->enable_multibyte_characters
= multibyte
;
3109 current_buffer
->undo_list
= undo_list
;
3115 /* Used to pass values from insert-file-contents to read_non_regular. */
3117 static int non_regular_fd
;
3118 static EMACS_INT non_regular_inserted
;
3119 static EMACS_INT non_regular_nbytes
;
3122 /* Read from a non-regular file.
3123 Read non_regular_trytry bytes max from non_regular_fd.
3124 Non_regular_inserted specifies where to put the read bytes.
3125 Value is the number of bytes read. */
3134 nbytes
= emacs_read (non_regular_fd
,
3135 BEG_ADDR
+ PT_BYTE
- BEG_BYTE
+ non_regular_inserted
,
3136 non_regular_nbytes
);
3138 return make_number (nbytes
);
3142 /* Condition-case handler used when reading from non-regular files
3143 in insert-file-contents. */
3146 read_non_regular_quit ()
3152 DEFUN ("insert-file-contents", Finsert_file_contents
, Sinsert_file_contents
,
3154 doc
: /* Insert contents of file FILENAME after point.
3155 Returns list of absolute file name and number of characters inserted.
3156 If second argument VISIT is non-nil, the buffer's visited filename and
3157 last save file modtime are set, and it is marked unmodified. If
3158 visiting and the file does not exist, visiting is completed before the
3161 The optional third and fourth arguments BEG and END specify what portion
3162 of the file to insert. These arguments count bytes in the file, not
3163 characters in the buffer. If VISIT is non-nil, BEG and END must be nil.
3165 If optional fifth argument REPLACE is non-nil, replace the current
3166 buffer contents (in the accessible portion) with the file contents.
3167 This is better than simply deleting and inserting the whole thing
3168 because (1) it preserves some marker positions and (2) it puts less data
3169 in the undo list. When REPLACE is non-nil, the second return value is
3170 the number of characters that replace previous buffer contents.
3172 This function does code conversion according to the value of
3173 `coding-system-for-read' or `file-coding-system-alist', and sets the
3174 variable `last-coding-system-used' to the coding system actually used. */)
3175 (filename
, visit
, beg
, end
, replace
)
3176 Lisp_Object filename
, visit
, beg
, end
, replace
;
3180 EMACS_INT inserted
= 0;
3182 register EMACS_INT how_much
;
3183 register EMACS_INT unprocessed
;
3184 int count
= SPECPDL_INDEX ();
3185 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
3186 Lisp_Object handler
, val
, insval
, orig_filename
, old_undo
;
3188 EMACS_INT total
= 0;
3189 int not_regular
= 0;
3190 unsigned char read_buf
[READ_BUF_SIZE
];
3191 struct coding_system coding
;
3192 unsigned char buffer
[1 << 14];
3193 int replace_handled
= 0;
3194 int set_coding_system
= 0;
3195 Lisp_Object coding_system
;
3197 Lisp_Object old_Vdeactivate_mark
= Vdeactivate_mark
;
3198 int we_locked_file
= 0;
3199 int deferred_remove_unwind_protect
= 0;
3201 if (current_buffer
->base_buffer
&& ! NILP (visit
))
3202 error ("Cannot do file visiting in an indirect buffer");
3204 if (!NILP (current_buffer
->read_only
))
3205 Fbarf_if_buffer_read_only ();
3209 orig_filename
= Qnil
;
3212 GCPRO5 (filename
, val
, p
, orig_filename
, old_undo
);
3214 CHECK_STRING (filename
);
3215 filename
= Fexpand_file_name (filename
, Qnil
);
3217 /* The value Qnil means that the coding system is not yet
3219 coding_system
= Qnil
;
3221 /* If the file name has special constructs in it,
3222 call the corresponding file handler. */
3223 handler
= Ffind_file_name_handler (filename
, Qinsert_file_contents
);
3224 if (!NILP (handler
))
3226 val
= call6 (handler
, Qinsert_file_contents
, filename
,
3227 visit
, beg
, end
, replace
);
3228 if (CONSP (val
) && CONSP (XCDR (val
)))
3229 inserted
= XINT (XCAR (XCDR (val
)));
3233 orig_filename
= filename
;
3234 filename
= ENCODE_FILE (filename
);
3240 Lisp_Object tem
= Vw32_get_true_file_attributes
;
3242 /* Tell stat to use expensive method to get accurate info. */
3243 Vw32_get_true_file_attributes
= Qt
;
3244 total
= stat (SDATA (filename
), &st
);
3245 Vw32_get_true_file_attributes
= tem
;
3249 if (stat (SDATA (filename
), &st
) < 0)
3250 #endif /* WINDOWSNT */
3252 if (fd
>= 0) emacs_close (fd
);
3255 report_file_error ("Opening input file", Fcons (orig_filename
, Qnil
));
3258 if (!NILP (Vcoding_system_for_read
))
3259 Fset (Qbuffer_file_coding_system
, Vcoding_system_for_read
);
3264 /* This code will need to be changed in order to work on named
3265 pipes, and it's probably just not worth it. So we should at
3266 least signal an error. */
3267 if (!S_ISREG (st
.st_mode
))
3274 if (! NILP (replace
) || ! NILP (beg
) || ! NILP (end
))
3275 xsignal2 (Qfile_error
,
3276 build_string ("not a regular file"), orig_filename
);
3281 if ((fd
= emacs_open (SDATA (filename
), O_RDONLY
, 0)) < 0)
3284 /* Replacement should preserve point as it preserves markers. */
3285 if (!NILP (replace
))
3286 record_unwind_protect (restore_point_unwind
, Fpoint_marker ());
3288 record_unwind_protect (close_file_unwind
, make_number (fd
));
3290 /* Can happen on any platform that uses long as type of off_t, but allows
3291 file sizes to exceed 2Gb, so give a suitable message. */
3292 if (! not_regular
&& st
.st_size
< 0)
3293 error ("Maximum buffer size exceeded");
3295 /* Prevent redisplay optimizations. */
3296 current_buffer
->clip_changed
= 1;
3300 if (!NILP (beg
) || !NILP (end
))
3301 error ("Attempt to visit less than an entire file");
3302 if (BEG
< Z
&& NILP (replace
))
3303 error ("Cannot do file visiting in a non-empty buffer");
3309 XSETFASTINT (beg
, 0);
3317 XSETINT (end
, st
.st_size
);
3319 /* Arithmetic overflow can occur if an Emacs integer cannot
3320 represent the file size, or if the calculations below
3321 overflow. The calculations below double the file size
3322 twice, so check that it can be multiplied by 4 safely. */
3323 if (XINT (end
) != st
.st_size
3324 /* Actually, it should test either INT_MAX or LONG_MAX
3325 depending on which one is used for EMACS_INT. But in
3326 any case, in practice, this test is redundant with the
3328 || st.st_size > INT_MAX / 4 */)
3329 error ("Maximum buffer size exceeded");
3331 /* The file size returned from stat may be zero, but data
3332 may be readable nonetheless, for example when this is a
3333 file in the /proc filesystem. */
3334 if (st
.st_size
== 0)
3335 XSETINT (end
, READ_BUF_SIZE
);
3339 if (EQ (Vcoding_system_for_read
, Qauto_save_coding
))
3341 coding_system
= coding_inherit_eol_type (Qutf_8_emacs
, Qunix
);
3342 setup_coding_system (coding_system
, &coding
);
3343 /* Ensure we set Vlast_coding_system_used. */
3344 set_coding_system
= 1;
3348 /* Decide the coding system to use for reading the file now
3349 because we can't use an optimized method for handling
3350 `coding:' tag if the current buffer is not empty. */
3351 if (!NILP (Vcoding_system_for_read
))
3352 coding_system
= Vcoding_system_for_read
;
3355 /* Don't try looking inside a file for a coding system
3356 specification if it is not seekable. */
3357 if (! not_regular
&& ! NILP (Vset_auto_coding_function
))
3359 /* Find a coding system specified in the heading two
3360 lines or in the tailing several lines of the file.
3361 We assume that the 1K-byte and 3K-byte for heading
3362 and tailing respectively are sufficient for this
3366 if (st
.st_size
<= (1024 * 4))
3367 nread
= emacs_read (fd
, read_buf
, 1024 * 4);
3370 nread
= emacs_read (fd
, read_buf
, 1024);
3373 if (lseek (fd
, st
.st_size
- (1024 * 3), 0) < 0)
3374 report_file_error ("Setting file position",
3375 Fcons (orig_filename
, Qnil
));
3376 nread
+= emacs_read (fd
, read_buf
+ nread
, 1024 * 3);
3381 error ("IO error reading %s: %s",
3382 SDATA (orig_filename
), emacs_strerror (errno
));
3385 struct buffer
*prev
= current_buffer
;
3389 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
3391 buffer
= Fget_buffer_create (build_string (" *code-converting-work*"));
3392 buf
= XBUFFER (buffer
);
3394 delete_all_overlays (buf
);
3395 buf
->directory
= current_buffer
->directory
;
3396 buf
->read_only
= Qnil
;
3397 buf
->filename
= Qnil
;
3398 buf
->undo_list
= Qt
;
3399 eassert (buf
->overlays_before
== NULL
);
3400 eassert (buf
->overlays_after
== NULL
);
3402 set_buffer_internal (buf
);
3404 buf
->enable_multibyte_characters
= Qnil
;
3406 insert_1_both (read_buf
, nread
, nread
, 0, 0, 0);
3407 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
3408 coding_system
= call2 (Vset_auto_coding_function
,
3409 filename
, make_number (nread
));
3410 set_buffer_internal (prev
);
3412 /* Discard the unwind protect for recovering the
3416 /* Rewind the file for the actual read done later. */
3417 if (lseek (fd
, 0, 0) < 0)
3418 report_file_error ("Setting file position",
3419 Fcons (orig_filename
, Qnil
));
3423 if (NILP (coding_system
))
3425 /* If we have not yet decided a coding system, check
3426 file-coding-system-alist. */
3427 Lisp_Object args
[6];
3429 args
[0] = Qinsert_file_contents
, args
[1] = orig_filename
;
3430 args
[2] = visit
, args
[3] = beg
, args
[4] = end
, args
[5] = replace
;
3431 coding_system
= Ffind_operation_coding_system (6, args
);
3432 if (CONSP (coding_system
))
3433 coding_system
= XCAR (coding_system
);
3437 if (NILP (coding_system
))
3438 coding_system
= Qundecided
;
3440 CHECK_CODING_SYSTEM (coding_system
);
3442 if (NILP (current_buffer
->enable_multibyte_characters
))
3443 /* We must suppress all character code conversion except for
3444 end-of-line conversion. */
3445 coding_system
= raw_text_coding_system (coding_system
);
3447 setup_coding_system (coding_system
, &coding
);
3448 /* Ensure we set Vlast_coding_system_used. */
3449 set_coding_system
= 1;
3452 /* If requested, replace the accessible part of the buffer
3453 with the file contents. Avoid replacing text at the
3454 beginning or end of the buffer that matches the file contents;
3455 that preserves markers pointing to the unchanged parts.
3457 Here we implement this feature in an optimized way
3458 for the case where code conversion is NOT needed.
3459 The following if-statement handles the case of conversion
3460 in a less optimal way.
3462 If the code conversion is "automatic" then we try using this
3463 method and hope for the best.
3464 But if we discover the need for conversion, we give up on this method
3465 and let the following if-statement handle the replace job. */
3468 && (NILP (coding_system
)
3469 || ! CODING_REQUIRE_DECODING (&coding
)))
3471 /* same_at_start and same_at_end count bytes,
3472 because file access counts bytes
3473 and BEG and END count bytes. */
3474 EMACS_INT same_at_start
= BEGV_BYTE
;
3475 EMACS_INT same_at_end
= ZV_BYTE
;
3477 /* There is still a possibility we will find the need to do code
3478 conversion. If that happens, we set this variable to 1 to
3479 give up on handling REPLACE in the optimized way. */
3480 int giveup_match_end
= 0;
3482 if (XINT (beg
) != 0)
3484 if (lseek (fd
, XINT (beg
), 0) < 0)
3485 report_file_error ("Setting file position",
3486 Fcons (orig_filename
, Qnil
));
3491 /* Count how many chars at the start of the file
3492 match the text at the beginning of the buffer. */
3495 EMACS_INT nread
, bufpos
;
3497 nread
= emacs_read (fd
, buffer
, sizeof buffer
);
3499 error ("IO error reading %s: %s",
3500 SDATA (orig_filename
), emacs_strerror (errno
));
3501 else if (nread
== 0)
3504 if (CODING_REQUIRE_DETECTION (&coding
))
3506 coding_system
= detect_coding_system (buffer
, nread
, nread
, 1, 0,
3508 setup_coding_system (coding_system
, &coding
);
3511 if (CODING_REQUIRE_DECODING (&coding
))
3512 /* We found that the file should be decoded somehow.
3513 Let's give up here. */
3515 giveup_match_end
= 1;
3520 while (bufpos
< nread
&& same_at_start
< ZV_BYTE
3521 && FETCH_BYTE (same_at_start
) == buffer
[bufpos
])
3522 same_at_start
++, bufpos
++;
3523 /* If we found a discrepancy, stop the scan.
3524 Otherwise loop around and scan the next bufferful. */
3525 if (bufpos
!= nread
)
3529 /* If the file matches the buffer completely,
3530 there's no need to replace anything. */
3531 if (same_at_start
- BEGV_BYTE
== XINT (end
))
3535 /* Truncate the buffer to the size of the file. */
3536 del_range_1 (same_at_start
, same_at_end
, 0, 0);
3541 /* Count how many chars at the end of the file
3542 match the text at the end of the buffer. But, if we have
3543 already found that decoding is necessary, don't waste time. */
3544 while (!giveup_match_end
)
3546 EMACS_INT total_read
, nread
, bufpos
, curpos
, trial
;
3548 /* At what file position are we now scanning? */
3549 curpos
= XINT (end
) - (ZV_BYTE
- same_at_end
);
3550 /* If the entire file matches the buffer tail, stop the scan. */
3553 /* How much can we scan in the next step? */
3554 trial
= min (curpos
, sizeof buffer
);
3555 if (lseek (fd
, curpos
- trial
, 0) < 0)
3556 report_file_error ("Setting file position",
3557 Fcons (orig_filename
, Qnil
));
3559 total_read
= nread
= 0;
3560 while (total_read
< trial
)
3562 nread
= emacs_read (fd
, buffer
+ total_read
, trial
- total_read
);
3564 error ("IO error reading %s: %s",
3565 SDATA (orig_filename
), emacs_strerror (errno
));
3566 else if (nread
== 0)
3568 total_read
+= nread
;
3571 /* Scan this bufferful from the end, comparing with
3572 the Emacs buffer. */
3573 bufpos
= total_read
;
3575 /* Compare with same_at_start to avoid counting some buffer text
3576 as matching both at the file's beginning and at the end. */
3577 while (bufpos
> 0 && same_at_end
> same_at_start
3578 && FETCH_BYTE (same_at_end
- 1) == buffer
[bufpos
- 1])
3579 same_at_end
--, bufpos
--;
3581 /* If we found a discrepancy, stop the scan.
3582 Otherwise loop around and scan the preceding bufferful. */
3585 /* If this discrepancy is because of code conversion,
3586 we cannot use this method; giveup and try the other. */
3587 if (same_at_end
> same_at_start
3588 && FETCH_BYTE (same_at_end
- 1) >= 0200
3589 && ! NILP (current_buffer
->enable_multibyte_characters
)
3590 && (CODING_MAY_REQUIRE_DECODING (&coding
)))
3591 giveup_match_end
= 1;
3600 if (! giveup_match_end
)
3604 /* We win! We can handle REPLACE the optimized way. */
3606 /* Extend the start of non-matching text area to multibyte
3607 character boundary. */
3608 if (! NILP (current_buffer
->enable_multibyte_characters
))
3609 while (same_at_start
> BEGV_BYTE
3610 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_start
)))
3613 /* Extend the end of non-matching text area to multibyte
3614 character boundary. */
3615 if (! NILP (current_buffer
->enable_multibyte_characters
))
3616 while (same_at_end
< ZV_BYTE
3617 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_end
)))
3620 /* Don't try to reuse the same piece of text twice. */
3621 overlap
= (same_at_start
- BEGV_BYTE
3622 - (same_at_end
+ st
.st_size
- ZV
));
3624 same_at_end
+= overlap
;
3626 /* Arrange to read only the nonmatching middle part of the file. */
3627 XSETFASTINT (beg
, XINT (beg
) + (same_at_start
- BEGV_BYTE
));
3628 XSETFASTINT (end
, XINT (end
) - (ZV_BYTE
- same_at_end
));
3630 del_range_byte (same_at_start
, same_at_end
, 0);
3631 /* Insert from the file at the proper position. */
3632 temp
= BYTE_TO_CHAR (same_at_start
);
3633 SET_PT_BOTH (temp
, same_at_start
);
3635 /* If display currently starts at beginning of line,
3636 keep it that way. */
3637 if (XBUFFER (XWINDOW (selected_window
)->buffer
) == current_buffer
)
3638 XWINDOW (selected_window
)->start_at_line_beg
= Fbolp ();
3640 replace_handled
= 1;
3644 /* If requested, replace the accessible part of the buffer
3645 with the file contents. Avoid replacing text at the
3646 beginning or end of the buffer that matches the file contents;
3647 that preserves markers pointing to the unchanged parts.
3649 Here we implement this feature for the case where code conversion
3650 is needed, in a simple way that needs a lot of memory.
3651 The preceding if-statement handles the case of no conversion
3652 in a more optimized way. */
3653 if (!NILP (replace
) && ! replace_handled
&& BEGV
< ZV
)
3655 EMACS_INT same_at_start
= BEGV_BYTE
;
3656 EMACS_INT same_at_end
= ZV_BYTE
;
3657 EMACS_INT same_at_start_charpos
;
3658 EMACS_INT inserted_chars
;
3661 unsigned char *decoded
;
3663 int this_count
= SPECPDL_INDEX ();
3664 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
3665 Lisp_Object conversion_buffer
;
3667 conversion_buffer
= code_conversion_save (1, multibyte
);
3669 /* First read the whole file, performing code conversion into
3670 CONVERSION_BUFFER. */
3672 if (lseek (fd
, XINT (beg
), 0) < 0)
3673 report_file_error ("Setting file position",
3674 Fcons (orig_filename
, Qnil
));
3676 total
= st
.st_size
; /* Total bytes in the file. */
3677 how_much
= 0; /* Bytes read from file so far. */
3678 inserted
= 0; /* Bytes put into CONVERSION_BUFFER so far. */
3679 unprocessed
= 0; /* Bytes not processed in previous loop. */
3681 GCPRO1 (conversion_buffer
);
3682 while (how_much
< total
)
3684 /* We read one bunch by one (READ_BUF_SIZE bytes) to allow
3685 quitting while reading a huge while. */
3686 /* try is reserved in some compilers (Microsoft C) */
3687 EMACS_INT trytry
= min (total
- how_much
,
3688 READ_BUF_SIZE
- unprocessed
);
3691 /* Allow quitting out of the actual I/O. */
3694 this = emacs_read (fd
, read_buf
+ unprocessed
, trytry
);
3706 BUF_TEMP_SET_PT (XBUFFER (conversion_buffer
),
3707 BUF_Z (XBUFFER (conversion_buffer
)));
3708 decode_coding_c_string (&coding
, read_buf
, unprocessed
+ this,
3710 unprocessed
= coding
.carryover_bytes
;
3711 if (coding
.carryover_bytes
> 0)
3712 bcopy (coding
.carryover
, read_buf
, unprocessed
);
3717 /* We should remove the unwind_protect calling
3718 close_file_unwind, but other stuff has been added the stack,
3719 so defer the removal till we reach the `handled' label. */
3720 deferred_remove_unwind_protect
= 1;
3722 /* At this point, HOW_MUCH should equal TOTAL, or should be <= 0
3723 if we couldn't read the file. */
3726 error ("IO error reading %s: %s",
3727 SDATA (orig_filename
), emacs_strerror (errno
));
3729 if (unprocessed
> 0)
3731 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
3732 decode_coding_c_string (&coding
, read_buf
, unprocessed
,
3734 coding
.mode
&= ~CODING_MODE_LAST_BLOCK
;
3737 coding_system
= CODING_ID_NAME (coding
.id
);
3738 set_coding_system
= 1;
3739 decoded
= BUF_BEG_ADDR (XBUFFER (conversion_buffer
));
3740 inserted
= (BUF_Z_BYTE (XBUFFER (conversion_buffer
))
3741 - BUF_BEG_BYTE (XBUFFER (conversion_buffer
)));
3743 /* Compare the beginning of the converted string with the buffer
3747 while (bufpos
< inserted
&& same_at_start
< same_at_end
3748 && FETCH_BYTE (same_at_start
) == decoded
[bufpos
])
3749 same_at_start
++, bufpos
++;
3751 /* If the file matches the head of buffer completely,
3752 there's no need to replace anything. */
3754 if (bufpos
== inserted
)
3756 /* Truncate the buffer to the size of the file. */
3757 if (same_at_start
== same_at_end
)
3760 del_range_byte (same_at_start
, same_at_end
, 0);
3763 unbind_to (this_count
, Qnil
);
3767 /* Extend the start of non-matching text area to the previous
3768 multibyte character boundary. */
3769 if (! NILP (current_buffer
->enable_multibyte_characters
))
3770 while (same_at_start
> BEGV_BYTE
3771 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_start
)))
3774 /* Scan this bufferful from the end, comparing with
3775 the Emacs buffer. */
3778 /* Compare with same_at_start to avoid counting some buffer text
3779 as matching both at the file's beginning and at the end. */
3780 while (bufpos
> 0 && same_at_end
> same_at_start
3781 && FETCH_BYTE (same_at_end
- 1) == decoded
[bufpos
- 1])
3782 same_at_end
--, bufpos
--;
3784 /* Extend the end of non-matching text area to the next
3785 multibyte character boundary. */
3786 if (! NILP (current_buffer
->enable_multibyte_characters
))
3787 while (same_at_end
< ZV_BYTE
3788 && ! CHAR_HEAD_P (FETCH_BYTE (same_at_end
)))
3791 /* Don't try to reuse the same piece of text twice. */
3792 overlap
= same_at_start
- BEGV_BYTE
- (same_at_end
+ inserted
- ZV_BYTE
);
3794 same_at_end
+= overlap
;
3796 /* If display currently starts at beginning of line,
3797 keep it that way. */
3798 if (XBUFFER (XWINDOW (selected_window
)->buffer
) == current_buffer
)
3799 XWINDOW (selected_window
)->start_at_line_beg
= Fbolp ();
3801 /* Replace the chars that we need to replace,
3802 and update INSERTED to equal the number of bytes
3803 we are taking from the decoded string. */
3804 inserted
-= (ZV_BYTE
- same_at_end
) + (same_at_start
- BEGV_BYTE
);
3806 if (same_at_end
!= same_at_start
)
3808 del_range_byte (same_at_start
, same_at_end
, 0);
3810 same_at_start
= GPT_BYTE
;
3814 temp
= BYTE_TO_CHAR (same_at_start
);
3816 /* Insert from the file at the proper position. */
3817 SET_PT_BOTH (temp
, same_at_start
);
3818 same_at_start_charpos
3819 = buf_bytepos_to_charpos (XBUFFER (conversion_buffer
),
3820 same_at_start
- BEGV_BYTE
3821 + BUF_BEG_BYTE (XBUFFER (conversion_buffer
)));
3823 = (buf_bytepos_to_charpos (XBUFFER (conversion_buffer
),
3824 same_at_start
+ inserted
- BEGV_BYTE
3825 + BUF_BEG_BYTE (XBUFFER (conversion_buffer
)))
3826 - same_at_start_charpos
);
3827 /* This binding is to avoid ask-user-about-supersession-threat
3828 being called in insert_from_buffer (via in
3829 prepare_to_modify_buffer). */
3830 specbind (intern ("buffer-file-name"), Qnil
);
3831 insert_from_buffer (XBUFFER (conversion_buffer
),
3832 same_at_start_charpos
, inserted_chars
, 0);
3833 /* Set `inserted' to the number of inserted characters. */
3834 inserted
= PT
- temp
;
3835 /* Set point before the inserted characters. */
3836 SET_PT_BOTH (temp
, same_at_start
);
3838 unbind_to (this_count
, Qnil
);
3845 register Lisp_Object temp
;
3847 total
= XINT (end
) - XINT (beg
);
3849 /* Make sure point-max won't overflow after this insertion. */
3850 XSETINT (temp
, total
);
3851 if (total
!= XINT (temp
))
3852 error ("Maximum buffer size exceeded");
3855 /* For a special file, all we can do is guess. */
3856 total
= READ_BUF_SIZE
;
3858 if (NILP (visit
) && inserted
> 0)
3860 #ifdef CLASH_DETECTION
3861 if (!NILP (current_buffer
->file_truename
)
3862 /* Make binding buffer-file-name to nil effective. */
3863 && !NILP (current_buffer
->filename
)
3864 && SAVE_MODIFF
>= MODIFF
)
3866 #endif /* CLASH_DETECTION */
3867 prepare_to_modify_buffer (GPT
, GPT
, NULL
);
3871 if (GAP_SIZE
< total
)
3872 make_gap (total
- GAP_SIZE
);
3874 if (XINT (beg
) != 0 || !NILP (replace
))
3876 if (lseek (fd
, XINT (beg
), 0) < 0)
3877 report_file_error ("Setting file position",
3878 Fcons (orig_filename
, Qnil
));
3881 /* In the following loop, HOW_MUCH contains the total bytes read so
3882 far for a regular file, and not changed for a special file. But,
3883 before exiting the loop, it is set to a negative value if I/O
3887 /* Total bytes inserted. */
3890 /* Here, we don't do code conversion in the loop. It is done by
3891 decode_coding_gap after all data are read into the buffer. */
3893 EMACS_INT gap_size
= GAP_SIZE
;
3895 while (how_much
< total
)
3897 /* try is reserved in some compilers (Microsoft C) */
3898 EMACS_INT trytry
= min (total
- how_much
, READ_BUF_SIZE
);
3905 /* Maybe make more room. */
3906 if (gap_size
< trytry
)
3908 make_gap (total
- gap_size
);
3909 gap_size
= GAP_SIZE
;
3912 /* Read from the file, capturing `quit'. When an
3913 error occurs, end the loop, and arrange for a quit
3914 to be signaled after decoding the text we read. */
3915 non_regular_fd
= fd
;
3916 non_regular_inserted
= inserted
;
3917 non_regular_nbytes
= trytry
;
3918 val
= internal_condition_case_1 (read_non_regular
, Qnil
, Qerror
,
3919 read_non_regular_quit
);
3930 /* Allow quitting out of the actual I/O. We don't make text
3931 part of the buffer until all the reading is done, so a C-g
3932 here doesn't do any harm. */
3935 this = emacs_read (fd
, BEG_ADDR
+ PT_BYTE
- BEG_BYTE
+ inserted
, trytry
);
3947 /* For a regular file, where TOTAL is the real size,
3948 count HOW_MUCH to compare with it.
3949 For a special file, where TOTAL is just a buffer size,
3950 so don't bother counting in HOW_MUCH.
3951 (INSERTED is where we count the number of characters inserted.) */
3958 /* Now we have read all the file data into the gap.
3959 If it was empty, undo marking the buffer modified. */
3963 #ifdef CLASH_DETECTION
3965 unlock_file (current_buffer
->file_truename
);
3967 Vdeactivate_mark
= old_Vdeactivate_mark
;
3970 Vdeactivate_mark
= Qt
;
3972 /* Make the text read part of the buffer. */
3973 GAP_SIZE
-= inserted
;
3975 GPT_BYTE
+= inserted
;
3977 ZV_BYTE
+= inserted
;
3982 /* Put an anchor to ensure multi-byte form ends at gap. */
3987 /* Discard the unwind protect for closing the file. */
3991 error ("IO error reading %s: %s",
3992 SDATA (orig_filename
), emacs_strerror (errno
));
3996 if (NILP (coding_system
))
3998 /* The coding system is not yet decided. Decide it by an
3999 optimized method for handling `coding:' tag.
4001 Note that we can get here only if the buffer was empty
4002 before the insertion. */
4004 if (!NILP (Vcoding_system_for_read
))
4005 coding_system
= Vcoding_system_for_read
;
4008 /* Since we are sure that the current buffer was empty
4009 before the insertion, we can toggle
4010 enable-multibyte-characters directly here without taking
4011 care of marker adjustment. By this way, we can run Lisp
4012 program safely before decoding the inserted text. */
4013 Lisp_Object unwind_data
;
4014 int count
= SPECPDL_INDEX ();
4016 unwind_data
= Fcons (current_buffer
->enable_multibyte_characters
,
4017 Fcons (current_buffer
->undo_list
,
4018 Fcurrent_buffer ()));
4019 current_buffer
->enable_multibyte_characters
= Qnil
;
4020 current_buffer
->undo_list
= Qt
;
4021 record_unwind_protect (decide_coding_unwind
, unwind_data
);
4023 if (inserted
> 0 && ! NILP (Vset_auto_coding_function
))
4025 coding_system
= call2 (Vset_auto_coding_function
,
4026 filename
, make_number (inserted
));
4029 if (NILP (coding_system
))
4031 /* If the coding system is not yet decided, check
4032 file-coding-system-alist. */
4033 Lisp_Object args
[6];
4035 args
[0] = Qinsert_file_contents
, args
[1] = orig_filename
;
4036 args
[2] = visit
, args
[3] = beg
, args
[4] = end
, args
[5] = Qnil
;
4037 coding_system
= Ffind_operation_coding_system (6, args
);
4038 if (CONSP (coding_system
))
4039 coding_system
= XCAR (coding_system
);
4041 unbind_to (count
, Qnil
);
4042 inserted
= Z_BYTE
- BEG_BYTE
;
4045 if (NILP (coding_system
))
4046 coding_system
= Qundecided
;
4048 CHECK_CODING_SYSTEM (coding_system
);
4050 if (NILP (current_buffer
->enable_multibyte_characters
))
4051 /* We must suppress all character code conversion except for
4052 end-of-line conversion. */
4053 coding_system
= raw_text_coding_system (coding_system
);
4054 setup_coding_system (coding_system
, &coding
);
4055 /* Ensure we set Vlast_coding_system_used. */
4056 set_coding_system
= 1;
4061 /* When we visit a file by raw-text, we change the buffer to
4063 if (CODING_FOR_UNIBYTE (&coding
)
4064 /* Can't do this if part of the buffer might be preserved. */
4066 /* Visiting a file with these coding system makes the buffer
4068 current_buffer
->enable_multibyte_characters
= Qnil
;
4071 coding
.dst_multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
4072 if (CODING_MAY_REQUIRE_DECODING (&coding
)
4073 && (inserted
> 0 || CODING_REQUIRE_FLUSHING (&coding
)))
4075 move_gap_both (PT
, PT_BYTE
);
4076 GAP_SIZE
+= inserted
;
4077 ZV_BYTE
-= inserted
;
4081 decode_coding_gap (&coding
, inserted
, inserted
);
4082 inserted
= coding
.produced_char
;
4083 coding_system
= CODING_ID_NAME (coding
.id
);
4085 else if (inserted
> 0)
4086 adjust_after_insert (PT
, PT_BYTE
, PT
+ inserted
, PT_BYTE
+ inserted
,
4089 /* Now INSERTED is measured in characters. */
4092 /* Use the conversion type to determine buffer-file-type
4093 (find-buffer-file-type is now used to help determine the
4095 if ((VECTORP (CODING_ID_EOL_TYPE (coding
.id
))
4096 || EQ (CODING_ID_EOL_TYPE (coding
.id
), Qunix
))
4097 && ! CODING_REQUIRE_DECODING (&coding
))
4098 current_buffer
->buffer_file_type
= Qt
;
4100 current_buffer
->buffer_file_type
= Qnil
;
4105 if (deferred_remove_unwind_protect
)
4106 /* If requested above, discard the unwind protect for closing the
4112 if (!EQ (current_buffer
->undo_list
, Qt
) && !nochange
)
4113 current_buffer
->undo_list
= Qnil
;
4117 current_buffer
->modtime
= st
.st_mtime
;
4118 current_buffer
->filename
= orig_filename
;
4121 SAVE_MODIFF
= MODIFF
;
4122 BUF_AUTOSAVE_MODIFF (current_buffer
) = MODIFF
;
4123 XSETFASTINT (current_buffer
->save_length
, Z
- BEG
);
4124 #ifdef CLASH_DETECTION
4127 if (!NILP (current_buffer
->file_truename
))
4128 unlock_file (current_buffer
->file_truename
);
4129 unlock_file (filename
);
4131 #endif /* CLASH_DETECTION */
4133 xsignal2 (Qfile_error
,
4134 build_string ("not a regular file"), orig_filename
);
4137 if (set_coding_system
)
4138 Vlast_coding_system_used
= coding_system
;
4140 if (! NILP (Ffboundp (Qafter_insert_file_set_coding
)))
4142 insval
= call2 (Qafter_insert_file_set_coding
, make_number (inserted
),
4144 if (! NILP (insval
))
4146 CHECK_NUMBER (insval
);
4147 inserted
= XFASTINT (insval
);
4151 /* Decode file format. */
4154 /* Don't run point motion or modification hooks when decoding. */
4155 int count
= SPECPDL_INDEX ();
4156 EMACS_INT old_inserted
= inserted
;
4157 specbind (Qinhibit_point_motion_hooks
, Qt
);
4158 specbind (Qinhibit_modification_hooks
, Qt
);
4160 /* Save old undo list and don't record undo for decoding. */
4161 old_undo
= current_buffer
->undo_list
;
4162 current_buffer
->undo_list
= Qt
;
4166 insval
= call3 (Qformat_decode
,
4167 Qnil
, make_number (inserted
), visit
);
4168 CHECK_NUMBER (insval
);
4169 inserted
= XFASTINT (insval
);
4173 /* If REPLACE is non-nil and we succeeded in not replacing the
4174 beginning or end of the buffer text with the file's contents,
4175 call format-decode with `point' positioned at the beginning
4176 of the buffer and `inserted' equalling the number of
4177 characters in the buffer. Otherwise, format-decode might
4178 fail to correctly analyze the beginning or end of the buffer.
4179 Hence we temporarily save `point' and `inserted' here and
4180 restore `point' iff format-decode did not insert or delete
4181 any text. Otherwise we leave `point' at point-min. */
4182 EMACS_INT opoint
= PT
;
4183 EMACS_INT opoint_byte
= PT_BYTE
;
4184 EMACS_INT oinserted
= ZV
- BEGV
;
4185 int ochars_modiff
= CHARS_MODIFF
;
4187 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
4188 insval
= call3 (Qformat_decode
,
4189 Qnil
, make_number (oinserted
), visit
);
4190 CHECK_NUMBER (insval
);
4191 if (ochars_modiff
== CHARS_MODIFF
)
4192 /* format_decode didn't modify buffer's characters => move
4193 point back to position before inserted text and leave
4194 value of inserted alone. */
4195 SET_PT_BOTH (opoint
, opoint_byte
);
4197 /* format_decode modified buffer's characters => consider
4198 entire buffer changed and leave point at point-min. */
4199 inserted
= XFASTINT (insval
);
4202 /* For consistency with format-decode call these now iff inserted > 0
4203 (martin 2007-06-28). */
4204 p
= Vafter_insert_file_functions
;
4209 insval
= call1 (XCAR (p
), make_number (inserted
));
4212 CHECK_NUMBER (insval
);
4213 inserted
= XFASTINT (insval
);
4218 /* For the rationale of this see the comment on
4219 format-decode above. */
4220 EMACS_INT opoint
= PT
;
4221 EMACS_INT opoint_byte
= PT_BYTE
;
4222 EMACS_INT oinserted
= ZV
- BEGV
;
4223 int ochars_modiff
= CHARS_MODIFF
;
4225 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
4226 insval
= call1 (XCAR (p
), make_number (oinserted
));
4229 CHECK_NUMBER (insval
);
4230 if (ochars_modiff
== CHARS_MODIFF
)
4231 /* after_insert_file_functions didn't modify
4232 buffer's characters => move point back to
4233 position before inserted text and leave value of
4235 SET_PT_BOTH (opoint
, opoint_byte
);
4237 /* after_insert_file_functions did modify buffer's
4238 characters => consider entire buffer changed and
4239 leave point at point-min. */
4240 inserted
= XFASTINT (insval
);
4250 current_buffer
->undo_list
= old_undo
;
4251 if (CONSP (old_undo
) && inserted
!= old_inserted
)
4253 /* Adjust the last undo record for the size change during
4254 the format conversion. */
4255 Lisp_Object tem
= XCAR (old_undo
);
4256 if (CONSP (tem
) && INTEGERP (XCAR (tem
))
4257 && INTEGERP (XCDR (tem
))
4258 && XFASTINT (XCDR (tem
)) == PT
+ old_inserted
)
4259 XSETCDR (tem
, make_number (PT
+ inserted
));
4263 /* If undo_list was Qt before, keep it that way.
4264 Otherwise start with an empty undo_list. */
4265 current_buffer
->undo_list
= EQ (old_undo
, Qt
) ? Qt
: Qnil
;
4267 unbind_to (count
, Qnil
);
4270 /* Call after-change hooks for the inserted text, aside from the case
4271 of normal visiting (not with REPLACE), which is done in a new buffer
4272 "before" the buffer is changed. */
4273 if (inserted
> 0 && total
> 0
4274 && (NILP (visit
) || !NILP (replace
)))
4276 signal_after_change (PT
, 0, inserted
);
4277 update_compositions (PT
, PT
, CHECK_BORDER
);
4281 && current_buffer
->modtime
== -1)
4283 /* If visiting nonexistent file, return nil. */
4284 report_file_error ("Opening input file", Fcons (orig_filename
, Qnil
));
4288 Fsignal (Qquit
, Qnil
);
4290 /* ??? Retval needs to be dealt with in all cases consistently. */
4292 val
= Fcons (orig_filename
,
4293 Fcons (make_number (inserted
),
4296 RETURN_UNGCPRO (unbind_to (count
, val
));
4299 static Lisp_Object build_annotations
P_ ((Lisp_Object
, Lisp_Object
));
4302 build_annotations_unwind (arg
)
4305 Vwrite_region_annotation_buffers
= arg
;
4309 /* Decide the coding-system to encode the data with. */
4312 choose_write_coding_system (start
, end
, filename
,
4313 append
, visit
, lockname
, coding
)
4314 Lisp_Object start
, end
, filename
, append
, visit
, lockname
;
4315 struct coding_system
*coding
;
4318 Lisp_Object eol_parent
= Qnil
;
4321 && NILP (Fstring_equal (current_buffer
->filename
,
4322 current_buffer
->auto_save_file_name
)))
4327 else if (!NILP (Vcoding_system_for_write
))
4329 val
= Vcoding_system_for_write
;
4330 if (coding_system_require_warning
4331 && !NILP (Ffboundp (Vselect_safe_coding_system_function
)))
4332 /* Confirm that VAL can surely encode the current region. */
4333 val
= call5 (Vselect_safe_coding_system_function
,
4334 start
, end
, Fcons (Qt
, Fcons (val
, Qnil
)),
4339 /* If the variable `buffer-file-coding-system' is set locally,
4340 it means that the file was read with some kind of code
4341 conversion or the variable is explicitly set by users. We
4342 had better write it out with the same coding system even if
4343 `enable-multibyte-characters' is nil.
4345 If it is not set locally, we anyway have to convert EOL
4346 format if the default value of `buffer-file-coding-system'
4347 tells that it is not Unix-like (LF only) format. */
4348 int using_default_coding
= 0;
4349 int force_raw_text
= 0;
4351 val
= current_buffer
->buffer_file_coding_system
;
4353 || NILP (Flocal_variable_p (Qbuffer_file_coding_system
, Qnil
)))
4356 if (NILP (current_buffer
->enable_multibyte_characters
))
4362 /* Check file-coding-system-alist. */
4363 Lisp_Object args
[7], coding_systems
;
4365 args
[0] = Qwrite_region
; args
[1] = start
; args
[2] = end
;
4366 args
[3] = filename
; args
[4] = append
; args
[5] = visit
;
4368 coding_systems
= Ffind_operation_coding_system (7, args
);
4369 if (CONSP (coding_systems
) && !NILP (XCDR (coding_systems
)))
4370 val
= XCDR (coding_systems
);
4375 /* If we still have not decided a coding system, use the
4376 default value of buffer-file-coding-system. */
4377 val
= current_buffer
->buffer_file_coding_system
;
4378 using_default_coding
= 1;
4381 if (! NILP (val
) && ! force_raw_text
)
4383 Lisp_Object spec
, attrs
;
4385 CHECK_CODING_SYSTEM_GET_SPEC (val
, spec
);
4386 attrs
= AREF (spec
, 0);
4387 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
4392 && !NILP (Ffboundp (Vselect_safe_coding_system_function
)))
4393 /* Confirm that VAL can surely encode the current region. */
4394 val
= call5 (Vselect_safe_coding_system_function
,
4395 start
, end
, val
, Qnil
, filename
);
4397 /* If the decided coding-system doesn't specify end-of-line
4398 format, we use that of
4399 `default-buffer-file-coding-system'. */
4400 if (! using_default_coding
4401 && ! NILP (buffer_defaults
.buffer_file_coding_system
))
4402 val
= (coding_inherit_eol_type
4403 (val
, buffer_defaults
.buffer_file_coding_system
));
4405 /* If we decide not to encode text, use `raw-text' or one of its
4408 val
= raw_text_coding_system (val
);
4411 val
= coding_inherit_eol_type (val
, eol_parent
);
4412 setup_coding_system (val
, coding
);
4414 if (!STRINGP (start
) && !NILP (current_buffer
->selective_display
))
4415 coding
->mode
|= CODING_MODE_SELECTIVE_DISPLAY
;
4419 DEFUN ("write-region", Fwrite_region
, Swrite_region
, 3, 7,
4420 "r\nFWrite region to file: \ni\ni\ni\np",
4421 doc
: /* Write current region into specified file.
4422 When called from a program, requires three arguments:
4423 START, END and FILENAME. START and END are normally buffer positions
4424 specifying the part of the buffer to write.
4425 If START is nil, that means to use the entire buffer contents.
4426 If START is a string, then output that string to the file
4427 instead of any buffer contents; END is ignored.
4429 Optional fourth argument APPEND if non-nil means
4430 append to existing file contents (if any). If it is an integer,
4431 seek to that offset in the file before writing.
4432 Optional fifth argument VISIT, if t or a string, means
4433 set the last-save-file-modtime of buffer to this file's modtime
4434 and mark buffer not modified.
4435 If VISIT is a string, it is a second file name;
4436 the output goes to FILENAME, but the buffer is marked as visiting VISIT.
4437 VISIT is also the file name to lock and unlock for clash detection.
4438 If VISIT is neither t nor nil nor a string,
4439 that means do not display the \"Wrote file\" message.
4440 The optional sixth arg LOCKNAME, if non-nil, specifies the name to
4441 use for locking and unlocking, overriding FILENAME and VISIT.
4442 The optional seventh arg MUSTBENEW, if non-nil, insists on a check
4443 for an existing file with the same name. If MUSTBENEW is `excl',
4444 that means to get an error if the file already exists; never overwrite.
4445 If MUSTBENEW is neither nil nor `excl', that means ask for
4446 confirmation before overwriting, but do go ahead and overwrite the file
4447 if the user confirms.
4449 This does code conversion according to the value of
4450 `coding-system-for-write', `buffer-file-coding-system', or
4451 `file-coding-system-alist', and sets the variable
4452 `last-coding-system-used' to the coding system actually used.
4454 This calls `write-region-annotate-functions' at the start, and
4455 `write-region-post-annotation-function' at the end. */)
4456 (start
, end
, filename
, append
, visit
, lockname
, mustbenew
)
4457 Lisp_Object start
, end
, filename
, append
, visit
, lockname
, mustbenew
;
4462 const unsigned char *fn
;
4464 int count
= SPECPDL_INDEX ();
4466 Lisp_Object handler
;
4467 Lisp_Object visit_file
;
4468 Lisp_Object annotations
;
4469 Lisp_Object encoded_filename
;
4470 int visiting
= (EQ (visit
, Qt
) || STRINGP (visit
));
4471 int quietly
= !NILP (visit
);
4472 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
4473 struct buffer
*given_buffer
;
4475 int buffer_file_type
= O_BINARY
;
4477 struct coding_system coding
;
4479 if (current_buffer
->base_buffer
&& visiting
)
4480 error ("Cannot do file visiting in an indirect buffer");
4482 if (!NILP (start
) && !STRINGP (start
))
4483 validate_region (&start
, &end
);
4486 GCPRO5 (start
, filename
, visit
, visit_file
, lockname
);
4488 filename
= Fexpand_file_name (filename
, Qnil
);
4490 if (!NILP (mustbenew
) && !EQ (mustbenew
, Qexcl
))
4491 barf_or_query_if_file_exists (filename
, "overwrite", 1, 0, 1);
4493 if (STRINGP (visit
))
4494 visit_file
= Fexpand_file_name (visit
, Qnil
);
4496 visit_file
= filename
;
4498 if (NILP (lockname
))
4499 lockname
= visit_file
;
4503 /* If the file name has special constructs in it,
4504 call the corresponding file handler. */
4505 handler
= Ffind_file_name_handler (filename
, Qwrite_region
);
4506 /* If FILENAME has no handler, see if VISIT has one. */
4507 if (NILP (handler
) && STRINGP (visit
))
4508 handler
= Ffind_file_name_handler (visit
, Qwrite_region
);
4510 if (!NILP (handler
))
4513 val
= call6 (handler
, Qwrite_region
, start
, end
,
4514 filename
, append
, visit
);
4518 SAVE_MODIFF
= MODIFF
;
4519 XSETFASTINT (current_buffer
->save_length
, Z
- BEG
);
4520 current_buffer
->filename
= visit_file
;
4526 record_unwind_protect (save_restriction_restore
, save_restriction_save ());
4528 /* Special kludge to simplify auto-saving. */
4531 /* Do it later, so write-region-annotate-function can work differently
4532 if we save "the buffer" vs "a region".
4533 This is useful in tar-mode. --Stef
4534 XSETFASTINT (start, BEG);
4535 XSETFASTINT (end, Z); */
4539 record_unwind_protect (build_annotations_unwind
,
4540 Vwrite_region_annotation_buffers
);
4541 Vwrite_region_annotation_buffers
= Fcons (Fcurrent_buffer (), Qnil
);
4542 count1
= SPECPDL_INDEX ();
4544 given_buffer
= current_buffer
;
4546 if (!STRINGP (start
))
4548 annotations
= build_annotations (start
, end
);
4550 if (current_buffer
!= given_buffer
)
4552 XSETFASTINT (start
, BEGV
);
4553 XSETFASTINT (end
, ZV
);
4559 XSETFASTINT (start
, BEGV
);
4560 XSETFASTINT (end
, ZV
);
4565 GCPRO5 (start
, filename
, annotations
, visit_file
, lockname
);
4567 /* Decide the coding-system to encode the data with.
4568 We used to make this choice before calling build_annotations, but that
4569 leads to problems when a write-annotate-function takes care of
4570 unsavable chars (as was the case with X-Symbol). */
4571 Vlast_coding_system_used
4572 = choose_write_coding_system (start
, end
, filename
,
4573 append
, visit
, lockname
, &coding
);
4575 #ifdef CLASH_DETECTION
4577 lock_file (lockname
);
4578 #endif /* CLASH_DETECTION */
4580 encoded_filename
= ENCODE_FILE (filename
);
4582 fn
= SDATA (encoded_filename
);
4586 desc
= emacs_open (fn
, O_WRONLY
| buffer_file_type
, 0);
4587 #else /* not DOS_NT */
4588 desc
= emacs_open (fn
, O_WRONLY
, 0);
4589 #endif /* not DOS_NT */
4591 if (desc
< 0 && (NILP (append
) || errno
== ENOENT
))
4593 desc
= emacs_open (fn
,
4594 O_WRONLY
| O_CREAT
| buffer_file_type
4595 | (EQ (mustbenew
, Qexcl
) ? O_EXCL
: O_TRUNC
),
4596 S_IREAD
| S_IWRITE
);
4597 #else /* not DOS_NT */
4598 desc
= emacs_open (fn
, O_WRONLY
| O_TRUNC
| O_CREAT
4599 | (EQ (mustbenew
, Qexcl
) ? O_EXCL
: 0),
4600 auto_saving
? auto_save_mode_bits
: 0666);
4601 #endif /* not DOS_NT */
4605 #ifdef CLASH_DETECTION
4607 if (!auto_saving
) unlock_file (lockname
);
4609 #endif /* CLASH_DETECTION */
4611 report_file_error ("Opening output file", Fcons (filename
, Qnil
));
4614 record_unwind_protect (close_file_unwind
, make_number (desc
));
4616 if (!NILP (append
) && !NILP (Ffile_regular_p (filename
)))
4620 if (NUMBERP (append
))
4621 ret
= lseek (desc
, XINT (append
), 1);
4623 ret
= lseek (desc
, 0, 2);
4626 #ifdef CLASH_DETECTION
4627 if (!auto_saving
) unlock_file (lockname
);
4628 #endif /* CLASH_DETECTION */
4630 report_file_error ("Lseek error", Fcons (filename
, Qnil
));
4639 if (STRINGP (start
))
4641 failure
= 0 > a_write (desc
, start
, 0, SCHARS (start
),
4642 &annotations
, &coding
);
4645 else if (XINT (start
) != XINT (end
))
4647 failure
= 0 > a_write (desc
, Qnil
,
4648 XINT (start
), XINT (end
) - XINT (start
),
4649 &annotations
, &coding
);
4654 /* If file was empty, still need to write the annotations */
4655 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
4656 failure
= 0 > a_write (desc
, Qnil
, XINT (end
), 0, &annotations
, &coding
);
4660 if (CODING_REQUIRE_FLUSHING (&coding
)
4661 && !(coding
.mode
& CODING_MODE_LAST_BLOCK
)
4664 /* We have to flush out a data. */
4665 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
4666 failure
= 0 > e_write (desc
, Qnil
, 1, 1, &coding
);
4673 /* Note fsync appears to change the modtime on BSD4.2 (both vax and sun).
4674 Disk full in NFS may be reported here. */
4675 /* mib says that closing the file will try to write as fast as NFS can do
4676 it, and that means the fsync here is not crucial for autosave files. */
4677 if (!auto_saving
&& !write_region_inhibit_fsync
&& fsync (desc
) < 0)
4679 /* If fsync fails with EINTR, don't treat that as serious. Also
4680 ignore EINVAL which happens when fsync is not supported on this
4682 if (errno
!= EINTR
&& errno
!= EINVAL
)
4683 failure
= 1, save_errno
= errno
;
4687 /* NFS can report a write failure now. */
4688 if (emacs_close (desc
) < 0)
4689 failure
= 1, save_errno
= errno
;
4693 /* Discard the unwind protect for close_file_unwind. */
4694 specpdl_ptr
= specpdl
+ count1
;
4696 /* Call write-region-post-annotation-function. */
4697 while (CONSP (Vwrite_region_annotation_buffers
))
4699 Lisp_Object buf
= XCAR (Vwrite_region_annotation_buffers
);
4700 if (!NILP (Fbuffer_live_p (buf
)))
4703 if (FUNCTIONP (Vwrite_region_post_annotation_function
))
4704 call0 (Vwrite_region_post_annotation_function
);
4706 Vwrite_region_annotation_buffers
4707 = XCDR (Vwrite_region_annotation_buffers
);
4710 unbind_to (count
, Qnil
);
4712 #ifdef CLASH_DETECTION
4714 unlock_file (lockname
);
4715 #endif /* CLASH_DETECTION */
4717 /* Do this before reporting IO error
4718 to avoid a "file has changed on disk" warning on
4719 next attempt to save. */
4721 current_buffer
->modtime
= st
.st_mtime
;
4724 error ("IO error writing %s: %s", SDATA (filename
),
4725 emacs_strerror (save_errno
));
4729 SAVE_MODIFF
= MODIFF
;
4730 XSETFASTINT (current_buffer
->save_length
, Z
- BEG
);
4731 current_buffer
->filename
= visit_file
;
4732 update_mode_lines
++;
4737 && ! NILP (Fstring_equal (current_buffer
->filename
,
4738 current_buffer
->auto_save_file_name
)))
4739 SAVE_MODIFF
= MODIFF
;
4745 message_with_string ((INTEGERP (append
)
4755 Lisp_Object
merge ();
4757 DEFUN ("car-less-than-car", Fcar_less_than_car
, Scar_less_than_car
, 2, 2, 0,
4758 doc
: /* Return t if (car A) is numerically less than (car B). */)
4762 return Flss (Fcar (a
), Fcar (b
));
4765 /* Build the complete list of annotations appropriate for writing out
4766 the text between START and END, by calling all the functions in
4767 write-region-annotate-functions and merging the lists they return.
4768 If one of these functions switches to a different buffer, we assume
4769 that buffer contains altered text. Therefore, the caller must
4770 make sure to restore the current buffer in all cases,
4771 as save-excursion would do. */
4774 build_annotations (start
, end
)
4775 Lisp_Object start
, end
;
4777 Lisp_Object annotations
;
4779 struct gcpro gcpro1
, gcpro2
;
4780 Lisp_Object original_buffer
;
4781 int i
, used_global
= 0;
4783 XSETBUFFER (original_buffer
, current_buffer
);
4786 p
= Vwrite_region_annotate_functions
;
4787 GCPRO2 (annotations
, p
);
4790 struct buffer
*given_buffer
= current_buffer
;
4791 if (EQ (Qt
, XCAR (p
)) && !used_global
)
4792 { /* Use the global value of the hook. */
4795 arg
[0] = Fdefault_value (Qwrite_region_annotate_functions
);
4797 p
= Fappend (2, arg
);
4800 Vwrite_region_annotations_so_far
= annotations
;
4801 res
= call2 (XCAR (p
), start
, end
);
4802 /* If the function makes a different buffer current,
4803 assume that means this buffer contains altered text to be output.
4804 Reset START and END from the buffer bounds
4805 and discard all previous annotations because they should have
4806 been dealt with by this function. */
4807 if (current_buffer
!= given_buffer
)
4809 Vwrite_region_annotation_buffers
4810 = Fcons (Fcurrent_buffer (),
4811 Vwrite_region_annotation_buffers
);
4812 XSETFASTINT (start
, BEGV
);
4813 XSETFASTINT (end
, ZV
);
4816 Flength (res
); /* Check basic validity of return value */
4817 annotations
= merge (annotations
, res
, Qcar_less_than_car
);
4821 /* Now do the same for annotation functions implied by the file-format */
4822 if (auto_saving
&& (!EQ (current_buffer
->auto_save_file_format
, Qt
)))
4823 p
= current_buffer
->auto_save_file_format
;
4825 p
= current_buffer
->file_format
;
4826 for (i
= 0; CONSP (p
); p
= XCDR (p
), ++i
)
4828 struct buffer
*given_buffer
= current_buffer
;
4830 Vwrite_region_annotations_so_far
= annotations
;
4832 /* Value is either a list of annotations or nil if the function
4833 has written annotations to a temporary buffer, which is now
4835 res
= call5 (Qformat_annotate_function
, XCAR (p
), start
, end
,
4836 original_buffer
, make_number (i
));
4837 if (current_buffer
!= given_buffer
)
4839 XSETFASTINT (start
, BEGV
);
4840 XSETFASTINT (end
, ZV
);
4845 annotations
= merge (annotations
, res
, Qcar_less_than_car
);
4853 /* Write to descriptor DESC the NCHARS chars starting at POS of STRING.
4854 If STRING is nil, POS is the character position in the current buffer.
4855 Intersperse with them the annotations from *ANNOT
4856 which fall within the range of POS to POS + NCHARS,
4857 each at its appropriate position.
4859 We modify *ANNOT by discarding elements as we use them up.
4861 The return value is negative in case of system call failure. */
4864 a_write (desc
, string
, pos
, nchars
, annot
, coding
)
4867 register int nchars
;
4870 struct coding_system
*coding
;
4874 int lastpos
= pos
+ nchars
;
4876 while (NILP (*annot
) || CONSP (*annot
))
4878 tem
= Fcar_safe (Fcar (*annot
));
4881 nextpos
= XFASTINT (tem
);
4883 /* If there are no more annotations in this range,
4884 output the rest of the range all at once. */
4885 if (! (nextpos
>= pos
&& nextpos
<= lastpos
))
4886 return e_write (desc
, string
, pos
, lastpos
, coding
);
4888 /* Output buffer text up to the next annotation's position. */
4891 if (0 > e_write (desc
, string
, pos
, nextpos
, coding
))
4895 /* Output the annotation. */
4896 tem
= Fcdr (Fcar (*annot
));
4899 if (0 > e_write (desc
, tem
, 0, SCHARS (tem
), coding
))
4902 *annot
= Fcdr (*annot
);
4908 /* Write text in the range START and END into descriptor DESC,
4909 encoding them with coding system CODING. If STRING is nil, START
4910 and END are character positions of the current buffer, else they
4911 are indexes to the string STRING. */
4914 e_write (desc
, string
, start
, end
, coding
)
4918 struct coding_system
*coding
;
4920 if (STRINGP (string
))
4923 end
= SCHARS (string
);
4926 /* We used to have a code for handling selective display here. But,
4927 now it is handled within encode_coding. */
4931 if (STRINGP (string
))
4933 coding
->src_multibyte
= SCHARS (string
) < SBYTES (string
);
4934 if (CODING_REQUIRE_ENCODING (coding
))
4936 encode_coding_object (coding
, string
,
4937 start
, string_char_to_byte (string
, start
),
4938 end
, string_char_to_byte (string
, end
), Qt
);
4942 coding
->dst_object
= string
;
4943 coding
->consumed_char
= SCHARS (string
);
4944 coding
->produced
= SBYTES (string
);
4949 int start_byte
= CHAR_TO_BYTE (start
);
4950 int end_byte
= CHAR_TO_BYTE (end
);
4952 coding
->src_multibyte
= (end
- start
) < (end_byte
- start_byte
);
4953 if (CODING_REQUIRE_ENCODING (coding
))
4955 encode_coding_object (coding
, Fcurrent_buffer (),
4956 start
, start_byte
, end
, end_byte
, Qt
);
4960 coding
->dst_object
= Qnil
;
4961 coding
->dst_pos_byte
= start_byte
;
4962 if (start
>= GPT
|| end
<= GPT
)
4964 coding
->consumed_char
= end
- start
;
4965 coding
->produced
= end_byte
- start_byte
;
4969 coding
->consumed_char
= GPT
- start
;
4970 coding
->produced
= GPT_BYTE
- start_byte
;
4975 if (coding
->produced
> 0)
4979 STRINGP (coding
->dst_object
)
4980 ? SDATA (coding
->dst_object
)
4981 : BYTE_POS_ADDR (coding
->dst_pos_byte
),
4984 if (coding
->produced
)
4987 start
+= coding
->consumed_char
;
4993 DEFUN ("verify-visited-file-modtime", Fverify_visited_file_modtime
,
4994 Sverify_visited_file_modtime
, 1, 1, 0,
4995 doc
: /* Return t if last mod time of BUF's visited file matches what BUF records.
4996 This means that the file has not been changed since it was visited or saved.
4997 See Info node `(elisp)Modification Time' for more details. */)
5003 Lisp_Object handler
;
5004 Lisp_Object filename
;
5009 if (!STRINGP (b
->filename
)) return Qt
;
5010 if (b
->modtime
== 0) return Qt
;
5012 /* If the file name has special constructs in it,
5013 call the corresponding file handler. */
5014 handler
= Ffind_file_name_handler (b
->filename
,
5015 Qverify_visited_file_modtime
);
5016 if (!NILP (handler
))
5017 return call2 (handler
, Qverify_visited_file_modtime
, buf
);
5019 filename
= ENCODE_FILE (b
->filename
);
5021 if (stat (SDATA (filename
), &st
) < 0)
5023 /* If the file doesn't exist now and didn't exist before,
5024 we say that it isn't modified, provided the error is a tame one. */
5025 if (errno
== ENOENT
|| errno
== EACCES
|| errno
== ENOTDIR
)
5030 if (st
.st_mtime
== b
->modtime
5031 /* If both are positive, accept them if they are off by one second. */
5032 || (st
.st_mtime
> 0 && b
->modtime
> 0
5033 && (st
.st_mtime
== b
->modtime
+ 1
5034 || st
.st_mtime
== b
->modtime
- 1)))
5039 DEFUN ("clear-visited-file-modtime", Fclear_visited_file_modtime
,
5040 Sclear_visited_file_modtime
, 0, 0, 0,
5041 doc
: /* Clear out records of last mod time of visited file.
5042 Next attempt to save will certainly not complain of a discrepancy. */)
5045 current_buffer
->modtime
= 0;
5049 DEFUN ("visited-file-modtime", Fvisited_file_modtime
,
5050 Svisited_file_modtime
, 0, 0, 0,
5051 doc
: /* Return the current buffer's recorded visited file modification time.
5052 The value is a list of the form (HIGH LOW), like the time values
5053 that `file-attributes' returns. If the current buffer has no recorded
5054 file modification time, this function returns 0.
5055 See Info node `(elisp)Modification Time' for more details. */)
5058 if (! current_buffer
->modtime
)
5059 return make_number (0);
5060 return make_time ((time_t) current_buffer
->modtime
);
5063 DEFUN ("set-visited-file-modtime", Fset_visited_file_modtime
,
5064 Sset_visited_file_modtime
, 0, 1, 0,
5065 doc
: /* Update buffer's recorded modification time from the visited file's time.
5066 Useful if the buffer was not read from the file normally
5067 or if the file itself has been changed for some known benign reason.
5068 An argument specifies the modification time value to use
5069 \(instead of that of the visited file), in the form of a list
5070 \(HIGH . LOW) or (HIGH LOW). */)
5072 Lisp_Object time_list
;
5074 if (!NILP (time_list
))
5075 current_buffer
->modtime
= cons_to_long (time_list
);
5078 register Lisp_Object filename
;
5080 Lisp_Object handler
;
5082 filename
= Fexpand_file_name (current_buffer
->filename
, Qnil
);
5084 /* If the file name has special constructs in it,
5085 call the corresponding file handler. */
5086 handler
= Ffind_file_name_handler (filename
, Qset_visited_file_modtime
);
5087 if (!NILP (handler
))
5088 /* The handler can find the file name the same way we did. */
5089 return call2 (handler
, Qset_visited_file_modtime
, Qnil
);
5091 filename
= ENCODE_FILE (filename
);
5093 if (stat (SDATA (filename
), &st
) >= 0)
5094 current_buffer
->modtime
= st
.st_mtime
;
5101 auto_save_error (error
)
5104 Lisp_Object args
[3], msg
;
5106 struct gcpro gcpro1
;
5110 auto_save_error_occurred
= 1;
5112 ring_bell (XFRAME (selected_frame
));
5114 args
[0] = build_string ("Auto-saving %s: %s");
5115 args
[1] = current_buffer
->name
;
5116 args
[2] = Ferror_message_string (error
);
5117 msg
= Fformat (3, args
);
5119 nbytes
= SBYTES (msg
);
5120 SAFE_ALLOCA (msgbuf
, char *, nbytes
);
5121 bcopy (SDATA (msg
), msgbuf
, nbytes
);
5123 for (i
= 0; i
< 3; ++i
)
5126 message2 (msgbuf
, nbytes
, STRING_MULTIBYTE (msg
));
5128 message2_nolog (msgbuf
, nbytes
, STRING_MULTIBYTE (msg
));
5129 Fsleep_for (make_number (1), Qnil
);
5143 auto_save_mode_bits
= 0666;
5145 /* Get visited file's mode to become the auto save file's mode. */
5146 if (! NILP (current_buffer
->filename
))
5148 if (stat (SDATA (current_buffer
->filename
), &st
) >= 0)
5149 /* But make sure we can overwrite it later! */
5150 auto_save_mode_bits
= st
.st_mode
| 0600;
5151 else if ((modes
= Ffile_modes (current_buffer
->filename
),
5153 /* Remote files don't cooperate with stat. */
5154 auto_save_mode_bits
= XINT (modes
) | 0600;
5158 Fwrite_region (Qnil
, Qnil
, current_buffer
->auto_save_file_name
, Qnil
,
5159 NILP (Vauto_save_visited_file_name
) ? Qlambda
: Qt
,
5164 do_auto_save_unwind (arg
) /* used as unwind-protect function */
5167 FILE *stream
= (FILE *) XSAVE_VALUE (arg
)->pointer
;
5179 do_auto_save_unwind_1 (value
) /* used as unwind-protect function */
5182 minibuffer_auto_raise
= XINT (value
);
5187 do_auto_save_make_dir (dir
)
5192 call2 (Qmake_directory
, dir
, Qt
);
5193 XSETFASTINT (mode
, 0700);
5194 return Fset_file_modes (dir
, mode
);
5198 do_auto_save_eh (ignore
)
5204 DEFUN ("do-auto-save", Fdo_auto_save
, Sdo_auto_save
, 0, 2, "",
5205 doc
: /* Auto-save all buffers that need it.
5206 This is all buffers that have auto-saving enabled
5207 and are changed since last auto-saved.
5208 Auto-saving writes the buffer into a file
5209 so that your editing is not lost if the system crashes.
5210 This file is not the file you visited; that changes only when you save.
5211 Normally we run the normal hook `auto-save-hook' before saving.
5213 A non-nil NO-MESSAGE argument means do not print any message if successful.
5214 A non-nil CURRENT-ONLY argument means save only current buffer. */)
5215 (no_message
, current_only
)
5216 Lisp_Object no_message
, current_only
;
5218 struct buffer
*old
= current_buffer
, *b
;
5219 Lisp_Object tail
, buf
;
5221 int do_handled_files
;
5223 FILE *stream
= NULL
;
5224 int count
= SPECPDL_INDEX ();
5225 int orig_minibuffer_auto_raise
= minibuffer_auto_raise
;
5226 int old_message_p
= 0;
5227 struct gcpro gcpro1
, gcpro2
;
5229 if (max_specpdl_size
< specpdl_size
+ 40)
5230 max_specpdl_size
= specpdl_size
+ 40;
5235 if (NILP (no_message
))
5237 old_message_p
= push_message ();
5238 record_unwind_protect (pop_message_unwind
, Qnil
);
5241 /* Ordinarily don't quit within this function,
5242 but don't make it impossible to quit (in case we get hung in I/O). */
5246 /* No GCPRO needed, because (when it matters) all Lisp_Object variables
5247 point to non-strings reached from Vbuffer_alist. */
5249 if (!NILP (Vrun_hooks
))
5250 call1 (Vrun_hooks
, intern ("auto-save-hook"));
5252 if (STRINGP (Vauto_save_list_file_name
))
5254 Lisp_Object listfile
;
5256 listfile
= Fexpand_file_name (Vauto_save_list_file_name
, Qnil
);
5258 /* Don't try to create the directory when shutting down Emacs,
5259 because creating the directory might signal an error, and
5260 that would leave Emacs in a strange state. */
5261 if (!NILP (Vrun_hooks
))
5265 GCPRO2 (dir
, listfile
);
5266 dir
= Ffile_name_directory (listfile
);
5267 if (NILP (Ffile_directory_p (dir
)))
5268 internal_condition_case_1 (do_auto_save_make_dir
,
5269 dir
, Fcons (Fcons (Qfile_error
, Qnil
), Qnil
),
5274 stream
= fopen (SDATA (listfile
), "w");
5277 record_unwind_protect (do_auto_save_unwind
,
5278 make_save_value (stream
, 0));
5279 record_unwind_protect (do_auto_save_unwind_1
,
5280 make_number (minibuffer_auto_raise
));
5281 minibuffer_auto_raise
= 0;
5283 auto_save_error_occurred
= 0;
5285 /* On first pass, save all files that don't have handlers.
5286 On second pass, save all files that do have handlers.
5288 If Emacs is crashing, the handlers may tweak what is causing
5289 Emacs to crash in the first place, and it would be a shame if
5290 Emacs failed to autosave perfectly ordinary files because it
5291 couldn't handle some ange-ftp'd file. */
5293 for (do_handled_files
= 0; do_handled_files
< 2; do_handled_files
++)
5294 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5296 buf
= XCDR (XCAR (tail
));
5299 /* Record all the buffers that have auto save mode
5300 in the special file that lists them. For each of these buffers,
5301 Record visited name (if any) and auto save name. */
5302 if (STRINGP (b
->auto_save_file_name
)
5303 && stream
!= NULL
&& do_handled_files
== 0)
5306 if (!NILP (b
->filename
))
5308 fwrite (SDATA (b
->filename
), 1,
5309 SBYTES (b
->filename
), stream
);
5311 putc ('\n', stream
);
5312 fwrite (SDATA (b
->auto_save_file_name
), 1,
5313 SBYTES (b
->auto_save_file_name
), stream
);
5314 putc ('\n', stream
);
5318 if (!NILP (current_only
)
5319 && b
!= current_buffer
)
5322 /* Don't auto-save indirect buffers.
5323 The base buffer takes care of it. */
5327 /* Check for auto save enabled
5328 and file changed since last auto save
5329 and file changed since last real save. */
5330 if (STRINGP (b
->auto_save_file_name
)
5331 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
5332 && BUF_AUTOSAVE_MODIFF (b
) < BUF_MODIFF (b
)
5333 /* -1 means we've turned off autosaving for a while--see below. */
5334 && XINT (b
->save_length
) >= 0
5335 && (do_handled_files
5336 || NILP (Ffind_file_name_handler (b
->auto_save_file_name
,
5339 EMACS_TIME before_time
, after_time
;
5341 EMACS_GET_TIME (before_time
);
5343 /* If we had a failure, don't try again for 20 minutes. */
5344 if (b
->auto_save_failure_time
>= 0
5345 && EMACS_SECS (before_time
) - b
->auto_save_failure_time
< 1200)
5348 set_buffer_internal (b
);
5349 if (NILP (Vauto_save_include_big_deletions
)
5350 && (XFASTINT (b
->save_length
) * 10
5351 > (BUF_Z (b
) - BUF_BEG (b
)) * 13)
5352 /* A short file is likely to change a large fraction;
5353 spare the user annoying messages. */
5354 && XFASTINT (b
->save_length
) > 5000
5355 /* These messages are frequent and annoying for `*mail*'. */
5356 && !EQ (b
->filename
, Qnil
)
5357 && NILP (no_message
))
5359 /* It has shrunk too much; turn off auto-saving here. */
5360 minibuffer_auto_raise
= orig_minibuffer_auto_raise
;
5361 message_with_string ("Buffer %s has shrunk a lot; auto save disabled in that buffer until next real save",
5363 minibuffer_auto_raise
= 0;
5364 /* Turn off auto-saving until there's a real save,
5365 and prevent any more warnings. */
5366 XSETINT (b
->save_length
, -1);
5367 Fsleep_for (make_number (1), Qnil
);
5370 if (!auto_saved
&& NILP (no_message
))
5371 message1 ("Auto-saving...");
5372 internal_condition_case (auto_save_1
, Qt
, auto_save_error
);
5374 BUF_AUTOSAVE_MODIFF (b
) = BUF_MODIFF (b
);
5375 XSETFASTINT (current_buffer
->save_length
, Z
- BEG
);
5376 set_buffer_internal (old
);
5378 EMACS_GET_TIME (after_time
);
5380 /* If auto-save took more than 60 seconds,
5381 assume it was an NFS failure that got a timeout. */
5382 if (EMACS_SECS (after_time
) - EMACS_SECS (before_time
) > 60)
5383 b
->auto_save_failure_time
= EMACS_SECS (after_time
);
5387 /* Prevent another auto save till enough input events come in. */
5388 record_auto_save ();
5390 if (auto_saved
&& NILP (no_message
))
5394 /* If we are going to restore an old message,
5395 give time to read ours. */
5396 sit_for (make_number (1), 0, 0);
5399 else if (!auto_save_error_occurred
)
5400 /* Don't overwrite the error message if an error occurred.
5401 If we displayed a message and then restored a state
5402 with no message, leave a "done" message on the screen. */
5403 message1 ("Auto-saving...done");
5408 /* This restores the message-stack status. */
5409 unbind_to (count
, Qnil
);
5413 DEFUN ("set-buffer-auto-saved", Fset_buffer_auto_saved
,
5414 Sset_buffer_auto_saved
, 0, 0, 0,
5415 doc
: /* Mark current buffer as auto-saved with its current text.
5416 No auto-save file will be written until the buffer changes again. */)
5419 /* FIXME: This should not be called in indirect buffers, since
5420 they're not autosaved. */
5421 BUF_AUTOSAVE_MODIFF (current_buffer
) = MODIFF
;
5422 XSETFASTINT (current_buffer
->save_length
, Z
- BEG
);
5423 current_buffer
->auto_save_failure_time
= -1;
5427 DEFUN ("clear-buffer-auto-save-failure", Fclear_buffer_auto_save_failure
,
5428 Sclear_buffer_auto_save_failure
, 0, 0, 0,
5429 doc
: /* Clear any record of a recent auto-save failure in the current buffer. */)
5432 current_buffer
->auto_save_failure_time
= -1;
5436 DEFUN ("recent-auto-save-p", Frecent_auto_save_p
, Srecent_auto_save_p
,
5438 doc
: /* Return t if current buffer has been auto-saved recently.
5439 More precisely, if it has been auto-saved since last read from or saved
5440 in the visited file. If the buffer has no visited file,
5441 then any auto-save counts as "recent". */)
5444 /* FIXME: maybe we should return nil for indirect buffers since
5445 they're never autosaved. */
5446 return (SAVE_MODIFF
< BUF_AUTOSAVE_MODIFF (current_buffer
) ? Qt
: Qnil
);
5449 /* Reading and completing file names */
5451 DEFUN ("next-read-file-uses-dialog-p", Fnext_read_file_uses_dialog_p
,
5452 Snext_read_file_uses_dialog_p
, 0, 0, 0,
5453 doc
: /* Return t if a call to `read-file-name' will use a dialog.
5454 The return value is only relevant for a call to `read-file-name' that happens
5455 before any other event (mouse or keypress) is handled. */)
5458 #if defined (USE_MOTIF) || defined (HAVE_NTGUI) || defined (USE_GTK)
5459 if ((NILP (last_nonmenu_event
) || CONSP (last_nonmenu_event
))
5469 Fread_file_name (prompt
, dir
, default_filename
, mustmatch
, initial
, predicate
)
5470 Lisp_Object prompt
, dir
, default_filename
, mustmatch
, initial
, predicate
;
5472 struct gcpro gcpro1
, gcpro2
;
5473 Lisp_Object args
[7];
5475 GCPRO1 (default_filename
);
5476 args
[0] = intern ("read-file-name");
5479 args
[3] = default_filename
;
5480 args
[4] = mustmatch
;
5482 args
[6] = predicate
;
5483 RETURN_UNGCPRO (Ffuncall (7, args
));
5490 Qoperations
= intern_c_string ("operations");
5491 Qexpand_file_name
= intern_c_string ("expand-file-name");
5492 Qsubstitute_in_file_name
= intern_c_string ("substitute-in-file-name");
5493 Qdirectory_file_name
= intern_c_string ("directory-file-name");
5494 Qfile_name_directory
= intern_c_string ("file-name-directory");
5495 Qfile_name_nondirectory
= intern_c_string ("file-name-nondirectory");
5496 Qunhandled_file_name_directory
= intern_c_string ("unhandled-file-name-directory");
5497 Qfile_name_as_directory
= intern_c_string ("file-name-as-directory");
5498 Qcopy_file
= intern_c_string ("copy-file");
5499 Qmake_directory_internal
= intern_c_string ("make-directory-internal");
5500 Qmake_directory
= intern_c_string ("make-directory");
5501 Qdelete_directory_internal
= intern_c_string ("delete-directory-internal");
5502 Qdelete_file
= intern_c_string ("delete-file");
5503 Qrename_file
= intern_c_string ("rename-file");
5504 Qadd_name_to_file
= intern_c_string ("add-name-to-file");
5505 Qmake_symbolic_link
= intern_c_string ("make-symbolic-link");
5506 Qfile_exists_p
= intern_c_string ("file-exists-p");
5507 Qfile_executable_p
= intern_c_string ("file-executable-p");
5508 Qfile_readable_p
= intern_c_string ("file-readable-p");
5509 Qfile_writable_p
= intern_c_string ("file-writable-p");
5510 Qfile_symlink_p
= intern_c_string ("file-symlink-p");
5511 Qaccess_file
= intern_c_string ("access-file");
5512 Qfile_directory_p
= intern_c_string ("file-directory-p");
5513 Qfile_regular_p
= intern_c_string ("file-regular-p");
5514 Qfile_accessible_directory_p
= intern_c_string ("file-accessible-directory-p");
5515 Qfile_modes
= intern_c_string ("file-modes");
5516 Qset_file_modes
= intern_c_string ("set-file-modes");
5517 Qset_file_times
= intern_c_string ("set-file-times");
5518 Qfile_newer_than_file_p
= intern_c_string ("file-newer-than-file-p");
5519 Qinsert_file_contents
= intern_c_string ("insert-file-contents");
5520 Qwrite_region
= intern_c_string ("write-region");
5521 Qverify_visited_file_modtime
= intern_c_string ("verify-visited-file-modtime");
5522 Qset_visited_file_modtime
= intern_c_string ("set-visited-file-modtime");
5523 Qauto_save_coding
= intern_c_string ("auto-save-coding");
5525 staticpro (&Qoperations
);
5526 staticpro (&Qexpand_file_name
);
5527 staticpro (&Qsubstitute_in_file_name
);
5528 staticpro (&Qdirectory_file_name
);
5529 staticpro (&Qfile_name_directory
);
5530 staticpro (&Qfile_name_nondirectory
);
5531 staticpro (&Qunhandled_file_name_directory
);
5532 staticpro (&Qfile_name_as_directory
);
5533 staticpro (&Qcopy_file
);
5534 staticpro (&Qmake_directory_internal
);
5535 staticpro (&Qmake_directory
);
5536 staticpro (&Qdelete_directory_internal
);
5537 staticpro (&Qdelete_file
);
5538 staticpro (&Qrename_file
);
5539 staticpro (&Qadd_name_to_file
);
5540 staticpro (&Qmake_symbolic_link
);
5541 staticpro (&Qfile_exists_p
);
5542 staticpro (&Qfile_executable_p
);
5543 staticpro (&Qfile_readable_p
);
5544 staticpro (&Qfile_writable_p
);
5545 staticpro (&Qaccess_file
);
5546 staticpro (&Qfile_symlink_p
);
5547 staticpro (&Qfile_directory_p
);
5548 staticpro (&Qfile_regular_p
);
5549 staticpro (&Qfile_accessible_directory_p
);
5550 staticpro (&Qfile_modes
);
5551 staticpro (&Qset_file_modes
);
5552 staticpro (&Qset_file_times
);
5553 staticpro (&Qfile_newer_than_file_p
);
5554 staticpro (&Qinsert_file_contents
);
5555 staticpro (&Qwrite_region
);
5556 staticpro (&Qverify_visited_file_modtime
);
5557 staticpro (&Qset_visited_file_modtime
);
5558 staticpro (&Qauto_save_coding
);
5560 Qfile_name_history
= intern_c_string ("file-name-history");
5561 Fset (Qfile_name_history
, Qnil
);
5562 staticpro (&Qfile_name_history
);
5564 Qfile_error
= intern_c_string ("file-error");
5565 staticpro (&Qfile_error
);
5566 Qfile_already_exists
= intern_c_string ("file-already-exists");
5567 staticpro (&Qfile_already_exists
);
5568 Qfile_date_error
= intern_c_string ("file-date-error");
5569 staticpro (&Qfile_date_error
);
5570 Qexcl
= intern_c_string ("excl");
5574 Qfind_buffer_file_type
= intern_c_string ("find-buffer-file-type");
5575 staticpro (&Qfind_buffer_file_type
);
5578 DEFVAR_LISP ("file-name-coding-system", &Vfile_name_coding_system
,
5579 doc
: /* *Coding system for encoding file names.
5580 If it is nil, `default-file-name-coding-system' (which see) is used. */);
5581 Vfile_name_coding_system
= Qnil
;
5583 DEFVAR_LISP ("default-file-name-coding-system",
5584 &Vdefault_file_name_coding_system
,
5585 doc
: /* Default coding system for encoding file names.
5586 This variable is used only when `file-name-coding-system' is nil.
5588 This variable is set/changed by the command `set-language-environment'.
5589 User should not set this variable manually,
5590 instead use `file-name-coding-system' to get a constant encoding
5591 of file names regardless of the current language environment. */);
5592 Vdefault_file_name_coding_system
= Qnil
;
5594 Qformat_decode
= intern_c_string ("format-decode");
5595 staticpro (&Qformat_decode
);
5596 Qformat_annotate_function
= intern_c_string ("format-annotate-function");
5597 staticpro (&Qformat_annotate_function
);
5598 Qafter_insert_file_set_coding
= intern_c_string ("after-insert-file-set-coding");
5599 staticpro (&Qafter_insert_file_set_coding
);
5601 Qcar_less_than_car
= intern_c_string ("car-less-than-car");
5602 staticpro (&Qcar_less_than_car
);
5604 Fput (Qfile_error
, Qerror_conditions
,
5605 Fpurecopy (list2 (Qfile_error
, Qerror
)));
5606 Fput (Qfile_error
, Qerror_message
,
5607 make_pure_c_string ("File error"));
5609 Fput (Qfile_already_exists
, Qerror_conditions
,
5610 Fpurecopy (list3 (Qfile_already_exists
, Qfile_error
, Qerror
)));
5611 Fput (Qfile_already_exists
, Qerror_message
,
5612 make_pure_c_string ("File already exists"));
5614 Fput (Qfile_date_error
, Qerror_conditions
,
5615 Fpurecopy (list3 (Qfile_date_error
, Qfile_error
, Qerror
)));
5616 Fput (Qfile_date_error
, Qerror_message
,
5617 make_pure_c_string ("Cannot set file date"));
5619 DEFVAR_LISP ("directory-sep-char", &Vdirectory_sep_char
,
5620 doc
: /* Directory separator character for built-in functions that return file names.
5621 The value is always ?/. Don't use this variable, just use `/'. */);
5622 XSETFASTINT (Vdirectory_sep_char
, '/');
5624 DEFVAR_LISP ("file-name-handler-alist", &Vfile_name_handler_alist
,
5625 doc
: /* *Alist of elements (REGEXP . HANDLER) for file names handled specially.
5626 If a file name matches REGEXP, then all I/O on that file is done by calling
5629 The first argument given to HANDLER is the name of the I/O primitive
5630 to be handled; the remaining arguments are the arguments that were
5631 passed to that primitive. For example, if you do
5632 (file-exists-p FILENAME)
5633 and FILENAME is handled by HANDLER, then HANDLER is called like this:
5634 (funcall HANDLER 'file-exists-p FILENAME)
5635 The function `find-file-name-handler' checks this list for a handler
5636 for its argument. */);
5637 Vfile_name_handler_alist
= Qnil
;
5639 DEFVAR_LISP ("set-auto-coding-function",
5640 &Vset_auto_coding_function
,
5641 doc
: /* If non-nil, a function to call to decide a coding system of file.
5642 Two arguments are passed to this function: the file name
5643 and the length of a file contents following the point.
5644 This function should return a coding system to decode the file contents.
5645 It should check the file name against `auto-coding-alist'.
5646 If no coding system is decided, it should check a coding system
5647 specified in the heading lines with the format:
5648 -*- ... coding: CODING-SYSTEM; ... -*-
5649 or local variable spec of the tailing lines with `coding:' tag. */);
5650 Vset_auto_coding_function
= Qnil
;
5652 DEFVAR_LISP ("after-insert-file-functions", &Vafter_insert_file_functions
,
5653 doc
: /* A list of functions to be called at the end of `insert-file-contents'.
5654 Each is passed one argument, the number of characters inserted,
5655 with point at the start of the inserted text. Each function
5656 should leave point the same, and return the new character count.
5657 If `insert-file-contents' is intercepted by a handler from
5658 `file-name-handler-alist', that handler is responsible for calling the
5659 functions in `after-insert-file-functions' if appropriate. */);
5660 Vafter_insert_file_functions
= Qnil
;
5662 DEFVAR_LISP ("write-region-annotate-functions", &Vwrite_region_annotate_functions
,
5663 doc
: /* A list of functions to be called at the start of `write-region'.
5664 Each is passed two arguments, START and END as for `write-region'.
5665 These are usually two numbers but not always; see the documentation
5666 for `write-region'. The function should return a list of pairs
5667 of the form (POSITION . STRING), consisting of strings to be effectively
5668 inserted at the specified positions of the file being written (1 means to
5669 insert before the first byte written). The POSITIONs must be sorted into
5672 If there are several annotation functions, the lists returned by these
5673 functions are merged destructively. As each annotation function runs,
5674 the variable `write-region-annotations-so-far' contains a list of all
5675 annotations returned by previous annotation functions.
5677 An annotation function can return with a different buffer current.
5678 Doing so removes the annotations returned by previous functions, and
5679 resets START and END to `point-min' and `point-max' of the new buffer.
5681 After `write-region' completes, Emacs calls the function stored in
5682 `write-region-post-annotation-function', once for each buffer that was
5683 current when building the annotations (i.e., at least once), with that
5684 buffer current. */);
5685 Vwrite_region_annotate_functions
= Qnil
;
5686 staticpro (&Qwrite_region_annotate_functions
);
5687 Qwrite_region_annotate_functions
5688 = intern_c_string ("write-region-annotate-functions");
5690 DEFVAR_LISP ("write-region-post-annotation-function",
5691 &Vwrite_region_post_annotation_function
,
5692 doc
: /* Function to call after `write-region' completes.
5693 The function is called with no arguments. If one or more of the
5694 annotation functions in `write-region-annotate-functions' changed the
5695 current buffer, the function stored in this variable is called for
5696 each of those additional buffers as well, in addition to the original
5697 buffer. The relevant buffer is current during each function call. */);
5698 Vwrite_region_post_annotation_function
= Qnil
;
5699 staticpro (&Vwrite_region_annotation_buffers
);
5701 DEFVAR_LISP ("write-region-annotations-so-far",
5702 &Vwrite_region_annotations_so_far
,
5703 doc
: /* When an annotation function is called, this holds the previous annotations.
5704 These are the annotations made by other annotation functions
5705 that were already called. See also `write-region-annotate-functions'. */);
5706 Vwrite_region_annotations_so_far
= Qnil
;
5708 DEFVAR_LISP ("inhibit-file-name-handlers", &Vinhibit_file_name_handlers
,
5709 doc
: /* A list of file name handlers that temporarily should not be used.
5710 This applies only to the operation `inhibit-file-name-operation'. */);
5711 Vinhibit_file_name_handlers
= Qnil
;
5713 DEFVAR_LISP ("inhibit-file-name-operation", &Vinhibit_file_name_operation
,
5714 doc
: /* The operation for which `inhibit-file-name-handlers' is applicable. */);
5715 Vinhibit_file_name_operation
= Qnil
;
5717 DEFVAR_LISP ("auto-save-list-file-name", &Vauto_save_list_file_name
,
5718 doc
: /* File name in which we write a list of all auto save file names.
5719 This variable is initialized automatically from `auto-save-list-file-prefix'
5720 shortly after Emacs reads your `.emacs' file, if you have not yet given it
5721 a non-nil value. */);
5722 Vauto_save_list_file_name
= Qnil
;
5724 DEFVAR_LISP ("auto-save-visited-file-name", &Vauto_save_visited_file_name
,
5725 doc
: /* Non-nil says auto-save a buffer in the file it is visiting, when practical.
5726 Normally auto-save files are written under other names. */);
5727 Vauto_save_visited_file_name
= Qnil
;
5729 DEFVAR_LISP ("auto-save-include-big-deletions", &Vauto_save_include_big_deletions
,
5730 doc
: /* If non-nil, auto-save even if a large part of the text is deleted.
5731 If nil, deleting a substantial portion of the text disables auto-save
5732 in the buffer; this is the default behavior, because the auto-save
5733 file is usually more useful if it contains the deleted text. */);
5734 Vauto_save_include_big_deletions
= Qnil
;
5737 DEFVAR_BOOL ("write-region-inhibit-fsync", &write_region_inhibit_fsync
,
5738 doc
: /* *Non-nil means don't call fsync in `write-region'.
5739 This variable affects calls to `write-region' as well as save commands.
5740 A non-nil value may result in data loss! */);
5741 write_region_inhibit_fsync
= 0;
5744 DEFVAR_BOOL ("delete-by-moving-to-trash", &delete_by_moving_to_trash
,
5745 doc
: /* Specifies whether to use the system's trash can.
5746 When non-nil, the function `move-file-to-trash' will be used by
5747 `delete-file' and `delete-directory'. */);
5748 delete_by_moving_to_trash
= 0;
5749 Qdelete_by_moving_to_trash
= intern_c_string ("delete-by-moving-to-trash");
5750 Qmove_file_to_trash
= intern_c_string ("move-file-to-trash");
5751 staticpro (&Qmove_file_to_trash
);
5752 Qcopy_directory
= intern_c_string ("copy-directory");
5753 staticpro (&Qcopy_directory
);
5754 Qdelete_directory
= intern_c_string ("delete-directory");
5755 staticpro (&Qdelete_directory
);
5757 defsubr (&Sfind_file_name_handler
);
5758 defsubr (&Sfile_name_directory
);
5759 defsubr (&Sfile_name_nondirectory
);
5760 defsubr (&Sunhandled_file_name_directory
);
5761 defsubr (&Sfile_name_as_directory
);
5762 defsubr (&Sdirectory_file_name
);
5763 defsubr (&Smake_temp_name
);
5764 defsubr (&Sexpand_file_name
);
5765 defsubr (&Ssubstitute_in_file_name
);
5766 defsubr (&Scopy_file
);
5767 defsubr (&Smake_directory_internal
);
5768 defsubr (&Sdelete_directory_internal
);
5769 defsubr (&Sdelete_file
);
5770 defsubr (&Srename_file
);
5771 defsubr (&Sadd_name_to_file
);
5772 defsubr (&Smake_symbolic_link
);
5773 defsubr (&Sfile_name_absolute_p
);
5774 defsubr (&Sfile_exists_p
);
5775 defsubr (&Sfile_executable_p
);
5776 defsubr (&Sfile_readable_p
);
5777 defsubr (&Sfile_writable_p
);
5778 defsubr (&Saccess_file
);
5779 defsubr (&Sfile_symlink_p
);
5780 defsubr (&Sfile_directory_p
);
5781 defsubr (&Sfile_accessible_directory_p
);
5782 defsubr (&Sfile_regular_p
);
5783 defsubr (&Sfile_modes
);
5784 defsubr (&Sset_file_modes
);
5785 defsubr (&Sset_file_times
);
5786 defsubr (&Sset_default_file_modes
);
5787 defsubr (&Sdefault_file_modes
);
5788 defsubr (&Sfile_newer_than_file_p
);
5789 defsubr (&Sinsert_file_contents
);
5790 defsubr (&Swrite_region
);
5791 defsubr (&Scar_less_than_car
);
5792 defsubr (&Sverify_visited_file_modtime
);
5793 defsubr (&Sclear_visited_file_modtime
);
5794 defsubr (&Svisited_file_modtime
);
5795 defsubr (&Sset_visited_file_modtime
);
5796 defsubr (&Sdo_auto_save
);
5797 defsubr (&Sset_buffer_auto_saved
);
5798 defsubr (&Sclear_buffer_auto_save_failure
);
5799 defsubr (&Srecent_auto_save_p
);
5801 defsubr (&Snext_read_file_uses_dialog_p
);
5804 defsubr (&Sunix_sync
);
5808 /* arch-tag: 64ba3fd7-f844-4fb2-ba4b-427eb928786c
5809 (do not change this comment) */