Merged from the latest developing branch.
[MacVim.git] / src / fileio.c
blob88188e5979417eea465f8798cf3c16b2fd4a7a23
1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
11 * fileio.c: read from and write to a file
14 #if defined(MSDOS) || defined(WIN16) || defined(WIN32) || defined(_WIN64)
15 # include "vimio.h" /* for lseek(), must be before vim.h */
16 #endif
18 #if defined __EMX__
19 # include "vimio.h" /* for mktemp(), CJW 1997-12-03 */
20 #endif
22 #include "vim.h"
24 #if defined(__TANDEM) || defined(__MINT__)
25 # include <limits.h> /* for SSIZE_MAX */
26 #endif
28 #if defined(HAVE_UTIME) && defined(HAVE_UTIME_H)
29 # include <utime.h> /* for struct utimbuf */
30 #endif
32 #define BUFSIZE 8192 /* size of normal write buffer */
33 #define SMBUFSIZE 256 /* size of emergency write buffer */
35 #ifdef FEAT_CRYPT
36 # define CRYPT_MAGIC "VimCrypt~01!" /* "01" is the version nr */
37 # define CRYPT_MAGIC_LEN 12 /* must be multiple of 4! */
38 #endif
40 /* Is there any system that doesn't have access()? */
41 #define USE_MCH_ACCESS
43 #if defined(sun) && defined(S_ISCHR)
44 # define OPEN_CHR_FILES
45 static int is_dev_fd_file(char_u *fname);
46 #endif
47 #ifdef FEAT_MBYTE
48 static char_u *next_fenc __ARGS((char_u **pp));
49 # ifdef FEAT_EVAL
50 static char_u *readfile_charconvert __ARGS((char_u *fname, char_u *fenc, int *fdp));
51 # endif
52 #endif
53 #ifdef FEAT_VIMINFO
54 static void check_marks_read __ARGS((void));
55 #endif
56 #ifdef FEAT_CRYPT
57 static char_u *check_for_cryptkey __ARGS((char_u *cryptkey, char_u *ptr, long *sizep, long *filesizep, int newfile));
58 #endif
59 #ifdef UNIX
60 static void set_file_time __ARGS((char_u *fname, time_t atime, time_t mtime));
61 #endif
62 static int set_rw_fname __ARGS((char_u *fname, char_u *sfname));
63 static int msg_add_fileformat __ARGS((int eol_type));
64 static void msg_add_eol __ARGS((void));
65 static int check_mtime __ARGS((buf_T *buf, struct stat *s));
66 static int time_differs __ARGS((long t1, long t2));
67 #ifdef FEAT_AUTOCMD
68 static int apply_autocmds_exarg __ARGS((event_T event, char_u *fname, char_u *fname_io, int force, buf_T *buf, exarg_T *eap));
69 static int au_find_group __ARGS((char_u *name));
71 # define AUGROUP_DEFAULT -1 /* default autocmd group */
72 # define AUGROUP_ERROR -2 /* erroneous autocmd group */
73 # define AUGROUP_ALL -3 /* all autocmd groups */
74 #endif
76 #if defined(FEAT_CRYPT) || defined(FEAT_MBYTE)
77 # define HAS_BW_FLAGS
78 # define FIO_LATIN1 0x01 /* convert Latin1 */
79 # define FIO_UTF8 0x02 /* convert UTF-8 */
80 # define FIO_UCS2 0x04 /* convert UCS-2 */
81 # define FIO_UCS4 0x08 /* convert UCS-4 */
82 # define FIO_UTF16 0x10 /* convert UTF-16 */
83 # ifdef WIN3264
84 # define FIO_CODEPAGE 0x20 /* convert MS-Windows codepage */
85 # define FIO_PUT_CP(x) (((x) & 0xffff) << 16) /* put codepage in top word */
86 # define FIO_GET_CP(x) (((x)>>16) & 0xffff) /* get codepage from top word */
87 # endif
88 # ifdef MACOS_X
89 # define FIO_MACROMAN 0x20 /* convert MacRoman */
90 # endif
91 # define FIO_ENDIAN_L 0x80 /* little endian */
92 # define FIO_ENCRYPTED 0x1000 /* encrypt written bytes */
93 # define FIO_NOCONVERT 0x2000 /* skip encoding conversion */
94 # define FIO_UCSBOM 0x4000 /* check for BOM at start of file */
95 # define FIO_ALL -1 /* allow all formats */
96 #endif
98 /* When converting, a read() or write() may leave some bytes to be converted
99 * for the next call. The value is guessed... */
100 #define CONV_RESTLEN 30
102 /* We have to guess how much a sequence of bytes may expand when converting
103 * with iconv() to be able to allocate a buffer. */
104 #define ICONV_MULT 8
107 * Structure to pass arguments from buf_write() to buf_write_bytes().
109 struct bw_info
111 int bw_fd; /* file descriptor */
112 char_u *bw_buf; /* buffer with data to be written */
113 int bw_len; /* length of data */
114 #ifdef HAS_BW_FLAGS
115 int bw_flags; /* FIO_ flags */
116 #endif
117 #ifdef FEAT_MBYTE
118 char_u bw_rest[CONV_RESTLEN]; /* not converted bytes */
119 int bw_restlen; /* nr of bytes in bw_rest[] */
120 int bw_first; /* first write call */
121 char_u *bw_conv_buf; /* buffer for writing converted chars */
122 int bw_conv_buflen; /* size of bw_conv_buf */
123 int bw_conv_error; /* set for conversion error */
124 linenr_T bw_conv_error_lnum; /* first line with error or zero */
125 linenr_T bw_start_lnum; /* line number at start of buffer */
126 # ifdef USE_ICONV
127 iconv_t bw_iconv_fd; /* descriptor for iconv() or -1 */
128 # endif
129 #endif
132 static int buf_write_bytes __ARGS((struct bw_info *ip));
134 #ifdef FEAT_MBYTE
135 static linenr_T readfile_linenr __ARGS((linenr_T linecnt, char_u *p, char_u *endp));
136 static int ucs2bytes __ARGS((unsigned c, char_u **pp, int flags));
137 static int need_conversion __ARGS((char_u *fenc));
138 static int get_fio_flags __ARGS((char_u *ptr));
139 static char_u *check_for_bom __ARGS((char_u *p, long size, int *lenp, int flags));
140 static int make_bom __ARGS((char_u *buf, char_u *name));
141 # ifdef WIN3264
142 static int get_win_fio_flags __ARGS((char_u *ptr));
143 # endif
144 # ifdef MACOS_X
145 static int get_mac_fio_flags __ARGS((char_u *ptr));
146 # endif
147 #endif
148 static int move_lines __ARGS((buf_T *frombuf, buf_T *tobuf));
149 #ifdef TEMPDIRNAMES
150 static void vim_settempdir __ARGS((char_u *tempdir));
151 #endif
152 #ifdef FEAT_AUTOCMD
153 static char *e_auchangedbuf = N_("E812: Autocommands changed buffer or buffer name");
154 #endif
156 void
157 filemess(buf, name, s, attr)
158 buf_T *buf;
159 char_u *name;
160 char_u *s;
161 int attr;
163 int msg_scroll_save;
165 if (msg_silent != 0)
166 return;
167 msg_add_fname(buf, name); /* put file name in IObuff with quotes */
168 /* If it's extremely long, truncate it. */
169 if (STRLEN(IObuff) > IOSIZE - 80)
170 IObuff[IOSIZE - 80] = NUL;
171 STRCAT(IObuff, s);
173 * For the first message may have to start a new line.
174 * For further ones overwrite the previous one, reset msg_scroll before
175 * calling filemess().
177 msg_scroll_save = msg_scroll;
178 if (shortmess(SHM_OVERALL) && !exiting && p_verbose == 0)
179 msg_scroll = FALSE;
180 if (!msg_scroll) /* wait a bit when overwriting an error msg */
181 check_for_delay(FALSE);
182 msg_start();
183 msg_scroll = msg_scroll_save;
184 msg_scrolled_ign = TRUE;
185 /* may truncate the message to avoid a hit-return prompt */
186 msg_outtrans_attr(msg_may_trunc(FALSE, IObuff), attr);
187 msg_clr_eos();
188 out_flush();
189 msg_scrolled_ign = FALSE;
193 * Read lines from file "fname" into the buffer after line "from".
195 * 1. We allocate blocks with lalloc, as big as possible.
196 * 2. Each block is filled with characters from the file with a single read().
197 * 3. The lines are inserted in the buffer with ml_append().
199 * (caller must check that fname != NULL, unless READ_STDIN is used)
201 * "lines_to_skip" is the number of lines that must be skipped
202 * "lines_to_read" is the number of lines that are appended
203 * When not recovering lines_to_skip is 0 and lines_to_read MAXLNUM.
205 * flags:
206 * READ_NEW starting to edit a new buffer
207 * READ_FILTER reading filter output
208 * READ_STDIN read from stdin instead of a file
209 * READ_BUFFER read from curbuf instead of a file (converting after reading
210 * stdin)
211 * READ_DUMMY read into a dummy buffer (to check if file contents changed)
213 * return FAIL for failure, OK otherwise
216 readfile(fname, sfname, from, lines_to_skip, lines_to_read, eap, flags)
217 char_u *fname;
218 char_u *sfname;
219 linenr_T from;
220 linenr_T lines_to_skip;
221 linenr_T lines_to_read;
222 exarg_T *eap; /* can be NULL! */
223 int flags;
225 int fd = 0;
226 int newfile = (flags & READ_NEW);
227 int check_readonly;
228 int filtering = (flags & READ_FILTER);
229 int read_stdin = (flags & READ_STDIN);
230 int read_buffer = (flags & READ_BUFFER);
231 int set_options = newfile || read_buffer
232 || (eap != NULL && eap->read_edit);
233 linenr_T read_buf_lnum = 1; /* next line to read from curbuf */
234 colnr_T read_buf_col = 0; /* next char to read from this line */
235 char_u c;
236 linenr_T lnum = from;
237 char_u *ptr = NULL; /* pointer into read buffer */
238 char_u *buffer = NULL; /* read buffer */
239 char_u *new_buffer = NULL; /* init to shut up gcc */
240 char_u *line_start = NULL; /* init to shut up gcc */
241 int wasempty; /* buffer was empty before reading */
242 colnr_T len;
243 long size = 0;
244 char_u *p;
245 long filesize = 0;
246 int skip_read = FALSE;
247 #ifdef FEAT_CRYPT
248 char_u *cryptkey = NULL;
249 #endif
250 int split = 0; /* number of split lines */
251 #define UNKNOWN 0x0fffffff /* file size is unknown */
252 linenr_T linecnt;
253 int error = FALSE; /* errors encountered */
254 int ff_error = EOL_UNKNOWN; /* file format with errors */
255 long linerest = 0; /* remaining chars in line */
256 #ifdef UNIX
257 int perm = 0;
258 int swap_mode = -1; /* protection bits for swap file */
259 #else
260 int perm;
261 #endif
262 int fileformat = 0; /* end-of-line format */
263 int keep_fileformat = FALSE;
264 struct stat st;
265 int file_readonly;
266 linenr_T skip_count = 0;
267 linenr_T read_count = 0;
268 int msg_save = msg_scroll;
269 linenr_T read_no_eol_lnum = 0; /* non-zero lnum when last line of
270 * last read was missing the eol */
271 int try_mac = (vim_strchr(p_ffs, 'm') != NULL);
272 int try_dos = (vim_strchr(p_ffs, 'd') != NULL);
273 int try_unix = (vim_strchr(p_ffs, 'x') != NULL);
274 int file_rewind = FALSE;
275 #ifdef FEAT_MBYTE
276 int can_retry;
277 linenr_T conv_error = 0; /* line nr with conversion error */
278 linenr_T illegal_byte = 0; /* line nr with illegal byte */
279 int keep_dest_enc = FALSE; /* don't retry when char doesn't fit
280 in destination encoding */
281 int bad_char_behavior = BAD_REPLACE;
282 /* BAD_KEEP, BAD_DROP or character to
283 * replace with */
284 char_u *tmpname = NULL; /* name of 'charconvert' output file */
285 int fio_flags = 0;
286 char_u *fenc; /* fileencoding to use */
287 int fenc_alloced; /* fenc_next is in allocated memory */
288 char_u *fenc_next = NULL; /* next item in 'fencs' or NULL */
289 int advance_fenc = FALSE;
290 long real_size = 0;
291 # ifdef USE_ICONV
292 iconv_t iconv_fd = (iconv_t)-1; /* descriptor for iconv() or -1 */
293 # ifdef FEAT_EVAL
294 int did_iconv = FALSE; /* TRUE when iconv() failed and trying
295 'charconvert' next */
296 # endif
297 # endif
298 int converted = FALSE; /* TRUE if conversion done */
299 int notconverted = FALSE; /* TRUE if conversion wanted but it
300 wasn't possible */
301 char_u conv_rest[CONV_RESTLEN];
302 int conv_restlen = 0; /* nr of bytes in conv_rest[] */
303 #endif
305 #ifdef FEAT_AUTOCMD
306 /* Remember the initial values of curbuf, curbuf->b_ffname and
307 * curbuf->b_fname to detect whether they are altered as a result of
308 * executing nasty autocommands. Also check if "fname" and "sfname"
309 * point to one of these values. */
310 buf_T *old_curbuf = curbuf;
311 char_u *old_b_ffname = curbuf->b_ffname;
312 char_u *old_b_fname = curbuf->b_fname;
313 int using_b_ffname = (fname == curbuf->b_ffname)
314 || (sfname == curbuf->b_ffname);
315 int using_b_fname = (fname == curbuf->b_fname)
316 || (sfname == curbuf->b_fname);
317 #endif
318 write_no_eol_lnum = 0; /* in case it was set by the previous read */
321 * If there is no file name yet, use the one for the read file.
322 * BF_NOTEDITED is set to reflect this.
323 * Don't do this for a read from a filter.
324 * Only do this when 'cpoptions' contains the 'f' flag.
326 if (curbuf->b_ffname == NULL
327 && !filtering
328 && fname != NULL
329 && vim_strchr(p_cpo, CPO_FNAMER) != NULL
330 && !(flags & READ_DUMMY))
332 if (set_rw_fname(fname, sfname) == FAIL)
333 return FAIL;
336 /* After reading a file the cursor line changes but we don't want to
337 * display the line. */
338 ex_no_reprint = TRUE;
340 /* don't display the file info for another buffer now */
341 need_fileinfo = FALSE;
344 * For Unix: Use the short file name whenever possible.
345 * Avoids problems with networks and when directory names are changed.
346 * Don't do this for MS-DOS, a "cd" in a sub-shell may have moved us to
347 * another directory, which we don't detect.
349 if (sfname == NULL)
350 sfname = fname;
351 #if defined(UNIX) || defined(__EMX__)
352 fname = sfname;
353 #endif
355 #ifdef FEAT_AUTOCMD
357 * The BufReadCmd and FileReadCmd events intercept the reading process by
358 * executing the associated commands instead.
360 if (!filtering && !read_stdin && !read_buffer)
362 pos_T pos;
364 pos = curbuf->b_op_start;
366 /* Set '[ mark to the line above where the lines go (line 1 if zero). */
367 curbuf->b_op_start.lnum = ((from == 0) ? 1 : from);
368 curbuf->b_op_start.col = 0;
370 if (newfile)
372 if (apply_autocmds_exarg(EVENT_BUFREADCMD, NULL, sfname,
373 FALSE, curbuf, eap))
374 #ifdef FEAT_EVAL
375 return aborting() ? FAIL : OK;
376 #else
377 return OK;
378 #endif
380 else if (apply_autocmds_exarg(EVENT_FILEREADCMD, sfname, sfname,
381 FALSE, NULL, eap))
382 #ifdef FEAT_EVAL
383 return aborting() ? FAIL : OK;
384 #else
385 return OK;
386 #endif
388 curbuf->b_op_start = pos;
390 #endif
392 if ((shortmess(SHM_OVER) || curbuf->b_help) && p_verbose == 0)
393 msg_scroll = FALSE; /* overwrite previous file message */
394 else
395 msg_scroll = TRUE; /* don't overwrite previous file message */
398 * If the name ends in a path separator, we can't open it. Check here,
399 * because reading the file may actually work, but then creating the swap
400 * file may destroy it! Reported on MS-DOS and Win 95.
401 * If the name is too long we might crash further on, quit here.
403 if (fname != NULL && *fname != NUL)
405 p = fname + STRLEN(fname);
406 if (after_pathsep(fname, p) || STRLEN(fname) >= MAXPATHL)
408 filemess(curbuf, fname, (char_u *)_("Illegal file name"), 0);
409 msg_end();
410 msg_scroll = msg_save;
411 return FAIL;
415 #ifdef UNIX
417 * On Unix it is possible to read a directory, so we have to
418 * check for it before the mch_open().
420 if (!read_stdin && !read_buffer)
422 perm = mch_getperm(fname);
423 if (perm >= 0 && !S_ISREG(perm) /* not a regular file ... */
424 # ifdef S_ISFIFO
425 && !S_ISFIFO(perm) /* ... or fifo */
426 # endif
427 # ifdef S_ISSOCK
428 && !S_ISSOCK(perm) /* ... or socket */
429 # endif
430 # ifdef OPEN_CHR_FILES
431 && !(S_ISCHR(perm) && is_dev_fd_file(fname))
432 /* ... or a character special file named /dev/fd/<n> */
433 # endif
436 if (S_ISDIR(perm))
437 filemess(curbuf, fname, (char_u *)_("is a directory"), 0);
438 else
439 filemess(curbuf, fname, (char_u *)_("is not a file"), 0);
440 msg_end();
441 msg_scroll = msg_save;
442 return FAIL;
445 # if defined(MSDOS) || defined(MSWIN) || defined(OS2)
447 * MS-Windows allows opening a device, but we will probably get stuck
448 * trying to read it.
450 if (!p_odev && mch_nodetype(fname) == NODE_WRITABLE)
452 filemess(curbuf, fname, (char_u *)_("is a device (disabled with 'opendevice' option)"), 0);
453 msg_end();
454 msg_scroll = msg_save;
455 return FAIL;
457 # endif
459 #endif
461 /* set default 'fileformat' */
462 if (set_options)
464 if (eap != NULL && eap->force_ff != 0)
465 set_fileformat(get_fileformat_force(curbuf, eap), OPT_LOCAL);
466 else if (*p_ffs != NUL)
467 set_fileformat(default_fileformat(), OPT_LOCAL);
470 /* set or reset 'binary' */
471 if (eap != NULL && eap->force_bin != 0)
473 int oldval = curbuf->b_p_bin;
475 curbuf->b_p_bin = (eap->force_bin == FORCE_BIN);
476 set_options_bin(oldval, curbuf->b_p_bin, OPT_LOCAL);
480 * When opening a new file we take the readonly flag from the file.
481 * Default is r/w, can be set to r/o below.
482 * Don't reset it when in readonly mode
483 * Only set/reset b_p_ro when BF_CHECK_RO is set.
485 check_readonly = (newfile && (curbuf->b_flags & BF_CHECK_RO));
486 if (check_readonly && !readonlymode)
487 curbuf->b_p_ro = FALSE;
489 if (newfile && !read_stdin && !read_buffer)
491 /* Remember time of file.
492 * For RISCOS, also remember the filetype.
494 if (mch_stat((char *)fname, &st) >= 0)
496 buf_store_time(curbuf, &st, fname);
497 curbuf->b_mtime_read = curbuf->b_mtime;
499 #if defined(RISCOS) && defined(FEAT_OSFILETYPE)
500 /* Read the filetype into the buffer local filetype option. */
501 mch_read_filetype(fname);
502 #endif
503 #ifdef UNIX
505 * Use the protection bits of the original file for the swap file.
506 * This makes it possible for others to read the name of the
507 * edited file from the swapfile, but only if they can read the
508 * edited file.
509 * Remove the "write" and "execute" bits for group and others
510 * (they must not write the swapfile).
511 * Add the "read" and "write" bits for the user, otherwise we may
512 * not be able to write to the file ourselves.
513 * Setting the bits is done below, after creating the swap file.
515 swap_mode = (st.st_mode & 0644) | 0600;
516 #endif
517 #ifdef FEAT_CW_EDITOR
518 /* Get the FSSpec on MacOS
519 * TODO: Update it properly when the buffer name changes
521 (void)GetFSSpecFromPath(curbuf->b_ffname, &curbuf->b_FSSpec);
522 #endif
523 #ifdef VMS
524 curbuf->b_fab_rfm = st.st_fab_rfm;
525 curbuf->b_fab_rat = st.st_fab_rat;
526 curbuf->b_fab_mrs = st.st_fab_mrs;
527 #endif
529 else
531 curbuf->b_mtime = 0;
532 curbuf->b_mtime_read = 0;
533 curbuf->b_orig_size = 0;
534 curbuf->b_orig_mode = 0;
537 /* Reset the "new file" flag. It will be set again below when the
538 * file doesn't exist. */
539 curbuf->b_flags &= ~(BF_NEW | BF_NEW_W);
543 * for UNIX: check readonly with perm and mch_access()
544 * for RISCOS: same as Unix, otherwise file gets re-datestamped!
545 * for MSDOS and Amiga: check readonly by trying to open the file for writing
547 file_readonly = FALSE;
548 if (read_stdin)
550 #if defined(MSDOS) || defined(MSWIN) || defined(OS2)
551 /* Force binary I/O on stdin to avoid CR-LF -> LF conversion. */
552 setmode(0, O_BINARY);
553 #endif
555 else if (!read_buffer)
557 #ifdef USE_MCH_ACCESS
558 if (
559 # ifdef UNIX
560 !(perm & 0222) ||
561 # endif
562 mch_access((char *)fname, W_OK))
563 file_readonly = TRUE;
564 fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
565 #else
566 if (!newfile
567 || readonlymode
568 || (fd = mch_open((char *)fname, O_RDWR | O_EXTRA, 0)) < 0)
570 file_readonly = TRUE;
571 /* try to open ro */
572 fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
574 #endif
577 if (fd < 0) /* cannot open at all */
579 #ifndef UNIX
580 int isdir_f;
581 #endif
582 msg_scroll = msg_save;
583 #ifndef UNIX
585 * On MSDOS and Amiga we can't open a directory, check here.
587 isdir_f = (mch_isdir(fname));
588 perm = mch_getperm(fname); /* check if the file exists */
589 if (isdir_f)
591 filemess(curbuf, sfname, (char_u *)_("is a directory"), 0);
592 curbuf->b_p_ro = TRUE; /* must use "w!" now */
594 else
595 #endif
596 if (newfile)
598 if (perm < 0)
601 * Set the 'new-file' flag, so that when the file has
602 * been created by someone else, a ":w" will complain.
604 curbuf->b_flags |= BF_NEW;
606 /* Create a swap file now, so that other Vims are warned
607 * that we are editing this file. Don't do this for a
608 * "nofile" or "nowrite" buffer type. */
609 #ifdef FEAT_QUICKFIX
610 if (!bt_dontwrite(curbuf))
611 #endif
613 check_need_swap(newfile);
614 #ifdef FEAT_AUTOCMD
615 /* SwapExists autocommand may mess things up */
616 if (curbuf != old_curbuf
617 || (using_b_ffname
618 && (old_b_ffname != curbuf->b_ffname))
619 || (using_b_fname
620 && (old_b_fname != curbuf->b_fname)))
622 EMSG(_(e_auchangedbuf));
623 return FAIL;
625 #endif
627 if (dir_of_file_exists(fname))
628 filemess(curbuf, sfname, (char_u *)_("[New File]"), 0);
629 else
630 filemess(curbuf, sfname,
631 (char_u *)_("[New DIRECTORY]"), 0);
632 #ifdef FEAT_VIMINFO
633 /* Even though this is a new file, it might have been
634 * edited before and deleted. Get the old marks. */
635 check_marks_read();
636 #endif
637 #ifdef FEAT_MBYTE
638 if (eap != NULL && eap->force_enc != 0)
640 /* set forced 'fileencoding' */
641 fenc = enc_canonize(eap->cmd + eap->force_enc);
642 if (fenc != NULL)
643 set_string_option_direct((char_u *)"fenc", -1,
644 fenc, OPT_FREE|OPT_LOCAL, 0);
645 vim_free(fenc);
647 #endif
648 #ifdef FEAT_AUTOCMD
649 apply_autocmds_exarg(EVENT_BUFNEWFILE, sfname, sfname,
650 FALSE, curbuf, eap);
651 #endif
652 /* remember the current fileformat */
653 save_file_ff(curbuf);
655 #if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
656 if (aborting()) /* autocmds may abort script processing */
657 return FAIL;
658 #endif
659 return OK; /* a new file is not an error */
661 else
663 filemess(curbuf, sfname, (char_u *)(
664 # ifdef EFBIG
665 (errno == EFBIG) ? _("[File too big]") :
666 # endif
667 _("[Permission Denied]")), 0);
668 curbuf->b_p_ro = TRUE; /* must use "w!" now */
672 return FAIL;
676 * Only set the 'ro' flag for readonly files the first time they are
677 * loaded. Help files always get readonly mode
679 if ((check_readonly && file_readonly) || curbuf->b_help)
680 curbuf->b_p_ro = TRUE;
682 if (set_options)
684 /* Don't change 'eol' if reading from buffer as it will already be
685 * correctly set when reading stdin. */
686 if (!read_buffer)
688 curbuf->b_p_eol = TRUE;
689 curbuf->b_start_eol = TRUE;
691 #ifdef FEAT_MBYTE
692 curbuf->b_p_bomb = FALSE;
693 curbuf->b_start_bomb = FALSE;
694 #endif
697 /* Create a swap file now, so that other Vims are warned that we are
698 * editing this file.
699 * Don't do this for a "nofile" or "nowrite" buffer type. */
700 #ifdef FEAT_QUICKFIX
701 if (!bt_dontwrite(curbuf))
702 #endif
704 check_need_swap(newfile);
705 #ifdef FEAT_AUTOCMD
706 if (!read_stdin && (curbuf != old_curbuf
707 || (using_b_ffname && (old_b_ffname != curbuf->b_ffname))
708 || (using_b_fname && (old_b_fname != curbuf->b_fname))))
710 EMSG(_(e_auchangedbuf));
711 if (!read_buffer)
712 close(fd);
713 return FAIL;
715 #endif
716 #ifdef UNIX
717 /* Set swap file protection bits after creating it. */
718 if (swap_mode > 0 && curbuf->b_ml.ml_mfp != NULL
719 && curbuf->b_ml.ml_mfp->mf_fname != NULL)
720 (void)mch_setperm(curbuf->b_ml.ml_mfp->mf_fname, (long)swap_mode);
721 #endif
724 #if defined(HAS_SWAP_EXISTS_ACTION)
725 /* If "Quit" selected at ATTENTION dialog, don't load the file */
726 if (swap_exists_action == SEA_QUIT)
728 if (!read_buffer && !read_stdin)
729 close(fd);
730 return FAIL;
732 #endif
734 ++no_wait_return; /* don't wait for return yet */
737 * Set '[ mark to the line above where the lines go (line 1 if zero).
739 curbuf->b_op_start.lnum = ((from == 0) ? 1 : from);
740 curbuf->b_op_start.col = 0;
742 #ifdef FEAT_AUTOCMD
743 if (!read_buffer)
745 int m = msg_scroll;
746 int n = msg_scrolled;
749 * The file must be closed again, the autocommands may want to change
750 * the file before reading it.
752 if (!read_stdin)
753 close(fd); /* ignore errors */
756 * The output from the autocommands should not overwrite anything and
757 * should not be overwritten: Set msg_scroll, restore its value if no
758 * output was done.
760 msg_scroll = TRUE;
761 if (filtering)
762 apply_autocmds_exarg(EVENT_FILTERREADPRE, NULL, sfname,
763 FALSE, curbuf, eap);
764 else if (read_stdin)
765 apply_autocmds_exarg(EVENT_STDINREADPRE, NULL, sfname,
766 FALSE, curbuf, eap);
767 else if (newfile)
768 apply_autocmds_exarg(EVENT_BUFREADPRE, NULL, sfname,
769 FALSE, curbuf, eap);
770 else
771 apply_autocmds_exarg(EVENT_FILEREADPRE, sfname, sfname,
772 FALSE, NULL, eap);
773 if (msg_scrolled == n)
774 msg_scroll = m;
776 #ifdef FEAT_EVAL
777 if (aborting()) /* autocmds may abort script processing */
779 --no_wait_return;
780 msg_scroll = msg_save;
781 curbuf->b_p_ro = TRUE; /* must use "w!" now */
782 return FAIL;
784 #endif
786 * Don't allow the autocommands to change the current buffer.
787 * Try to re-open the file.
789 * Don't allow the autocommands to change the buffer name either
790 * (cd for example) if it invalidates fname or sfname.
792 if (!read_stdin && (curbuf != old_curbuf
793 || (using_b_ffname && (old_b_ffname != curbuf->b_ffname))
794 || (using_b_fname && (old_b_fname != curbuf->b_fname))
795 || (fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0)) < 0))
797 --no_wait_return;
798 msg_scroll = msg_save;
799 if (fd < 0)
800 EMSG(_("E200: *ReadPre autocommands made the file unreadable"));
801 else
802 EMSG(_("E201: *ReadPre autocommands must not change current buffer"));
803 curbuf->b_p_ro = TRUE; /* must use "w!" now */
804 return FAIL;
807 #endif /* FEAT_AUTOCMD */
809 /* Autocommands may add lines to the file, need to check if it is empty */
810 wasempty = (curbuf->b_ml.ml_flags & ML_EMPTY);
812 if (!recoverymode && !filtering && !(flags & READ_DUMMY))
815 * Show the user that we are busy reading the input. Sometimes this
816 * may take a while. When reading from stdin another program may
817 * still be running, don't move the cursor to the last line, unless
818 * always using the GUI.
820 if (read_stdin)
822 #ifndef ALWAYS_USE_GUI
823 mch_msg(_("Vim: Reading from stdin...\n"));
824 #endif
825 #ifdef FEAT_GUI
826 /* Also write a message in the GUI window, if there is one. */
827 if (gui.in_use && !gui.dying && !gui.starting)
829 p = (char_u *)_("Reading from stdin...");
830 gui_write(p, (int)STRLEN(p));
832 #endif
834 else if (!read_buffer)
835 filemess(curbuf, sfname, (char_u *)"", 0);
838 msg_scroll = FALSE; /* overwrite the file message */
841 * Set linecnt now, before the "retry" caused by a wrong guess for
842 * fileformat, and after the autocommands, which may change them.
844 linecnt = curbuf->b_ml.ml_line_count;
846 #ifdef FEAT_MBYTE
847 /* "++bad=" argument. */
848 if (eap != NULL && eap->bad_char != 0)
850 bad_char_behavior = eap->bad_char;
851 if (set_options)
852 curbuf->b_bad_char = eap->bad_char;
854 else
855 curbuf->b_bad_char = 0;
858 * Decide which 'encoding' to use or use first.
860 if (eap != NULL && eap->force_enc != 0)
862 fenc = enc_canonize(eap->cmd + eap->force_enc);
863 fenc_alloced = TRUE;
864 keep_dest_enc = TRUE;
866 else if (curbuf->b_p_bin)
868 fenc = (char_u *)""; /* binary: don't convert */
869 fenc_alloced = FALSE;
871 else if (curbuf->b_help)
873 char_u firstline[80];
874 int fc;
876 /* Help files are either utf-8 or latin1. Try utf-8 first, if this
877 * fails it must be latin1.
878 * Always do this when 'encoding' is "utf-8". Otherwise only do
879 * this when needed to avoid [converted] remarks all the time.
880 * It is needed when the first line contains non-ASCII characters.
881 * That is only in *.??x files. */
882 fenc = (char_u *)"latin1";
883 c = enc_utf8;
884 if (!c && !read_stdin)
886 fc = fname[STRLEN(fname) - 1];
887 if (TOLOWER_ASC(fc) == 'x')
889 /* Read the first line (and a bit more). Immediately rewind to
890 * the start of the file. If the read() fails "len" is -1. */
891 len = vim_read(fd, firstline, 80);
892 lseek(fd, (off_t)0L, SEEK_SET);
893 for (p = firstline; p < firstline + len; ++p)
894 if (*p >= 0x80)
896 c = TRUE;
897 break;
902 if (c)
904 fenc_next = fenc;
905 fenc = (char_u *)"utf-8";
907 /* When the file is utf-8 but a character doesn't fit in
908 * 'encoding' don't retry. In help text editing utf-8 bytes
909 * doesn't make sense. */
910 if (!enc_utf8)
911 keep_dest_enc = TRUE;
913 fenc_alloced = FALSE;
915 else if (*p_fencs == NUL)
917 fenc = curbuf->b_p_fenc; /* use format from buffer */
918 fenc_alloced = FALSE;
920 else
922 fenc_next = p_fencs; /* try items in 'fileencodings' */
923 fenc = next_fenc(&fenc_next);
924 fenc_alloced = TRUE;
926 #endif
929 * Jump back here to retry reading the file in different ways.
930 * Reasons to retry:
931 * - encoding conversion failed: try another one from "fenc_next"
932 * - BOM detected and fenc was set, need to setup conversion
933 * - "fileformat" check failed: try another
935 * Variables set for special retry actions:
936 * "file_rewind" Rewind the file to start reading it again.
937 * "advance_fenc" Advance "fenc" using "fenc_next".
938 * "skip_read" Re-use already read bytes (BOM detected).
939 * "did_iconv" iconv() conversion failed, try 'charconvert'.
940 * "keep_fileformat" Don't reset "fileformat".
942 * Other status indicators:
943 * "tmpname" When != NULL did conversion with 'charconvert'.
944 * Output file has to be deleted afterwards.
945 * "iconv_fd" When != -1 did conversion with iconv().
947 retry:
949 if (file_rewind)
951 if (read_buffer)
953 read_buf_lnum = 1;
954 read_buf_col = 0;
956 else if (read_stdin || lseek(fd, (off_t)0L, SEEK_SET) != 0)
958 /* Can't rewind the file, give up. */
959 error = TRUE;
960 goto failed;
962 /* Delete the previously read lines. */
963 while (lnum > from)
964 ml_delete(lnum--, FALSE);
965 file_rewind = FALSE;
966 #ifdef FEAT_MBYTE
967 if (set_options)
969 curbuf->b_p_bomb = FALSE;
970 curbuf->b_start_bomb = FALSE;
972 conv_error = 0;
973 #endif
977 * When retrying with another "fenc" and the first time "fileformat"
978 * will be reset.
980 if (keep_fileformat)
981 keep_fileformat = FALSE;
982 else
984 if (eap != NULL && eap->force_ff != 0)
986 fileformat = get_fileformat_force(curbuf, eap);
987 try_unix = try_dos = try_mac = FALSE;
989 else if (curbuf->b_p_bin)
990 fileformat = EOL_UNIX; /* binary: use Unix format */
991 else if (*p_ffs == NUL)
992 fileformat = get_fileformat(curbuf);/* use format from buffer */
993 else
994 fileformat = EOL_UNKNOWN; /* detect from file */
997 #ifdef FEAT_MBYTE
998 # ifdef USE_ICONV
999 if (iconv_fd != (iconv_t)-1)
1001 /* aborted conversion with iconv(), close the descriptor */
1002 iconv_close(iconv_fd);
1003 iconv_fd = (iconv_t)-1;
1005 # endif
1007 if (advance_fenc)
1010 * Try the next entry in 'fileencodings'.
1012 advance_fenc = FALSE;
1014 if (eap != NULL && eap->force_enc != 0)
1016 /* Conversion given with "++cc=" wasn't possible, read
1017 * without conversion. */
1018 notconverted = TRUE;
1019 conv_error = 0;
1020 if (fenc_alloced)
1021 vim_free(fenc);
1022 fenc = (char_u *)"";
1023 fenc_alloced = FALSE;
1025 else
1027 if (fenc_alloced)
1028 vim_free(fenc);
1029 if (fenc_next != NULL)
1031 fenc = next_fenc(&fenc_next);
1032 fenc_alloced = (fenc_next != NULL);
1034 else
1036 fenc = (char_u *)"";
1037 fenc_alloced = FALSE;
1040 if (tmpname != NULL)
1042 mch_remove(tmpname); /* delete converted file */
1043 vim_free(tmpname);
1044 tmpname = NULL;
1049 * Conversion may be required when the encoding of the file is different
1050 * from 'encoding' or 'encoding' is UTF-16, UCS-2 or UCS-4.
1052 fio_flags = 0;
1053 converted = need_conversion(fenc);
1054 if (converted)
1057 /* "ucs-bom" means we need to check the first bytes of the file
1058 * for a BOM. */
1059 if (STRCMP(fenc, ENC_UCSBOM) == 0)
1060 fio_flags = FIO_UCSBOM;
1063 * Check if UCS-2/4 or Latin1 to UTF-8 conversion needs to be
1064 * done. This is handled below after read(). Prepare the
1065 * fio_flags to avoid having to parse the string each time.
1066 * Also check for Unicode to Latin1 conversion, because iconv()
1067 * appears not to handle this correctly. This works just like
1068 * conversion to UTF-8 except how the resulting character is put in
1069 * the buffer.
1071 else if (enc_utf8 || STRCMP(p_enc, "latin1") == 0)
1072 fio_flags = get_fio_flags(fenc);
1074 # ifdef WIN3264
1076 * Conversion from an MS-Windows codepage to UTF-8 or another codepage
1077 * is handled with MultiByteToWideChar().
1079 if (fio_flags == 0)
1080 fio_flags = get_win_fio_flags(fenc);
1081 # endif
1083 # ifdef MACOS_X
1084 /* Conversion from Apple MacRoman to latin1 or UTF-8 */
1085 if (fio_flags == 0)
1086 fio_flags = get_mac_fio_flags(fenc);
1087 # endif
1089 # ifdef USE_ICONV
1091 * Try using iconv() if we can't convert internally.
1093 if (fio_flags == 0
1094 # ifdef FEAT_EVAL
1095 && !did_iconv
1096 # endif
1098 iconv_fd = (iconv_t)my_iconv_open(
1099 enc_utf8 ? (char_u *)"utf-8" : p_enc, fenc);
1100 # endif
1102 # ifdef FEAT_EVAL
1104 * Use the 'charconvert' expression when conversion is required
1105 * and we can't do it internally or with iconv().
1107 if (fio_flags == 0 && !read_stdin && !read_buffer && *p_ccv != NUL
1108 # ifdef USE_ICONV
1109 && iconv_fd == (iconv_t)-1
1110 # endif
1113 # ifdef USE_ICONV
1114 did_iconv = FALSE;
1115 # endif
1116 /* Skip conversion when it's already done (retry for wrong
1117 * "fileformat"). */
1118 if (tmpname == NULL)
1120 tmpname = readfile_charconvert(fname, fenc, &fd);
1121 if (tmpname == NULL)
1123 /* Conversion failed. Try another one. */
1124 advance_fenc = TRUE;
1125 if (fd < 0)
1127 /* Re-opening the original file failed! */
1128 EMSG(_("E202: Conversion made file unreadable!"));
1129 error = TRUE;
1130 goto failed;
1132 goto retry;
1136 else
1137 # endif
1139 if (fio_flags == 0
1140 # ifdef USE_ICONV
1141 && iconv_fd == (iconv_t)-1
1142 # endif
1145 /* Conversion wanted but we can't.
1146 * Try the next conversion in 'fileencodings' */
1147 advance_fenc = TRUE;
1148 goto retry;
1153 /* Set "can_retry" when it's possible to rewind the file and try with
1154 * another "fenc" value. It's FALSE when no other "fenc" to try, reading
1155 * stdin or fixed at a specific encoding. */
1156 can_retry = (*fenc != NUL && !read_stdin && !keep_dest_enc);
1157 #endif
1159 if (!skip_read)
1161 linerest = 0;
1162 filesize = 0;
1163 skip_count = lines_to_skip;
1164 read_count = lines_to_read;
1165 #ifdef FEAT_MBYTE
1166 conv_restlen = 0;
1167 #endif
1170 while (!error && !got_int)
1173 * We allocate as much space for the file as we can get, plus
1174 * space for the old line plus room for one terminating NUL.
1175 * The amount is limited by the fact that read() only can read
1176 * upto max_unsigned characters (and other things).
1178 #if SIZEOF_INT <= 2
1179 if (linerest >= 0x7ff0)
1181 ++split;
1182 *ptr = NL; /* split line by inserting a NL */
1183 size = 1;
1185 else
1186 #endif
1188 if (!skip_read)
1190 #if SIZEOF_INT > 2
1191 # if defined(SSIZE_MAX) && (SSIZE_MAX < 0x10000L)
1192 size = SSIZE_MAX; /* use max I/O size, 52K */
1193 # else
1194 size = 0x10000L; /* use buffer >= 64K */
1195 # endif
1196 #else
1197 size = 0x7ff0L - linerest; /* limit buffer to 32K */
1198 #endif
1200 for ( ; size >= 10; size = (long)((long_u)size >> 1))
1202 if ((new_buffer = lalloc((long_u)(size + linerest + 1),
1203 FALSE)) != NULL)
1204 break;
1206 if (new_buffer == NULL)
1208 do_outofmem_msg((long_u)(size * 2 + linerest + 1));
1209 error = TRUE;
1210 break;
1212 if (linerest) /* copy characters from the previous buffer */
1213 mch_memmove(new_buffer, ptr - linerest, (size_t)linerest);
1214 vim_free(buffer);
1215 buffer = new_buffer;
1216 ptr = buffer + linerest;
1217 line_start = buffer;
1219 #ifdef FEAT_MBYTE
1220 /* May need room to translate into.
1221 * For iconv() we don't really know the required space, use a
1222 * factor ICONV_MULT.
1223 * latin1 to utf-8: 1 byte becomes up to 2 bytes
1224 * utf-16 to utf-8: 2 bytes become up to 3 bytes, 4 bytes
1225 * become up to 4 bytes, size must be multiple of 2
1226 * ucs-2 to utf-8: 2 bytes become up to 3 bytes, size must be
1227 * multiple of 2
1228 * ucs-4 to utf-8: 4 bytes become up to 6 bytes, size must be
1229 * multiple of 4 */
1230 real_size = (int)size;
1231 # ifdef USE_ICONV
1232 if (iconv_fd != (iconv_t)-1)
1233 size = size / ICONV_MULT;
1234 else
1235 # endif
1236 if (fio_flags & FIO_LATIN1)
1237 size = size / 2;
1238 else if (fio_flags & (FIO_UCS2 | FIO_UTF16))
1239 size = (size * 2 / 3) & ~1;
1240 else if (fio_flags & FIO_UCS4)
1241 size = (size * 2 / 3) & ~3;
1242 else if (fio_flags == FIO_UCSBOM)
1243 size = size / ICONV_MULT; /* worst case */
1244 # ifdef WIN3264
1245 else if (fio_flags & FIO_CODEPAGE)
1246 size = size / ICONV_MULT; /* also worst case */
1247 # endif
1248 # ifdef MACOS_X
1249 else if (fio_flags & FIO_MACROMAN)
1250 size = size / ICONV_MULT; /* also worst case */
1251 # endif
1252 #endif
1254 #ifdef FEAT_MBYTE
1255 if (conv_restlen > 0)
1257 /* Insert unconverted bytes from previous line. */
1258 mch_memmove(ptr, conv_rest, conv_restlen);
1259 ptr += conv_restlen;
1260 size -= conv_restlen;
1262 #endif
1264 if (read_buffer)
1267 * Read bytes from curbuf. Used for converting text read
1268 * from stdin.
1270 if (read_buf_lnum > from)
1271 size = 0;
1272 else
1274 int n, ni;
1275 long tlen;
1277 tlen = 0;
1278 for (;;)
1280 p = ml_get(read_buf_lnum) + read_buf_col;
1281 n = (int)STRLEN(p);
1282 if ((int)tlen + n + 1 > size)
1284 /* Filled up to "size", append partial line.
1285 * Change NL to NUL to reverse the effect done
1286 * below. */
1287 n = (int)(size - tlen);
1288 for (ni = 0; ni < n; ++ni)
1290 if (p[ni] == NL)
1291 ptr[tlen++] = NUL;
1292 else
1293 ptr[tlen++] = p[ni];
1295 read_buf_col += n;
1296 break;
1298 else
1300 /* Append whole line and new-line. Change NL
1301 * to NUL to reverse the effect done below. */
1302 for (ni = 0; ni < n; ++ni)
1304 if (p[ni] == NL)
1305 ptr[tlen++] = NUL;
1306 else
1307 ptr[tlen++] = p[ni];
1309 ptr[tlen++] = NL;
1310 read_buf_col = 0;
1311 if (++read_buf_lnum > from)
1313 /* When the last line didn't have an
1314 * end-of-line don't add it now either. */
1315 if (!curbuf->b_p_eol)
1316 --tlen;
1317 size = tlen;
1318 break;
1324 else
1327 * Read bytes from the file.
1329 size = vim_read(fd, ptr, size);
1332 if (size <= 0)
1334 if (size < 0) /* read error */
1335 error = TRUE;
1336 #ifdef FEAT_MBYTE
1337 else if (conv_restlen > 0)
1340 * Reached end-of-file but some trailing bytes could
1341 * not be converted. Truncated file?
1344 /* When we did a conversion report an error. */
1345 if (fio_flags != 0
1346 # ifdef USE_ICONV
1347 || iconv_fd != (iconv_t)-1
1348 # endif
1351 if (conv_error == 0)
1352 conv_error = curbuf->b_ml.ml_line_count
1353 - linecnt + 1;
1355 /* Remember the first linenr with an illegal byte */
1356 else if (illegal_byte == 0)
1357 illegal_byte = curbuf->b_ml.ml_line_count
1358 - linecnt + 1;
1359 if (bad_char_behavior == BAD_DROP)
1361 *(ptr - conv_restlen) = NUL;
1362 conv_restlen = 0;
1364 else
1366 /* Replace the trailing bytes with the replacement
1367 * character if we were converting; if we weren't,
1368 * leave the UTF8 checking code to do it, as it
1369 * works slightly differently. */
1370 if (bad_char_behavior != BAD_KEEP && (fio_flags != 0
1371 # ifdef USE_ICONV
1372 || iconv_fd != (iconv_t)-1
1373 # endif
1376 while (conv_restlen > 0)
1378 *(--ptr) = bad_char_behavior;
1379 --conv_restlen;
1382 fio_flags = 0; /* don't convert this */
1383 # ifdef USE_ICONV
1384 if (iconv_fd != (iconv_t)-1)
1386 iconv_close(iconv_fd);
1387 iconv_fd = (iconv_t)-1;
1389 # endif
1392 #endif
1395 #ifdef FEAT_CRYPT
1397 * At start of file: Check for magic number of encryption.
1399 if (filesize == 0)
1400 cryptkey = check_for_cryptkey(cryptkey, ptr, &size,
1401 &filesize, newfile);
1403 * Decrypt the read bytes.
1405 if (cryptkey != NULL && size > 0)
1406 for (p = ptr; p < ptr + size; ++p)
1407 ZDECODE(*p);
1408 #endif
1410 skip_read = FALSE;
1412 #ifdef FEAT_MBYTE
1414 * At start of file (or after crypt magic number): Check for BOM.
1415 * Also check for a BOM for other Unicode encodings, but not after
1416 * converting with 'charconvert' or when a BOM has already been
1417 * found.
1419 if ((filesize == 0
1420 # ifdef FEAT_CRYPT
1421 || (filesize == CRYPT_MAGIC_LEN && cryptkey != NULL)
1422 # endif
1424 && (fio_flags == FIO_UCSBOM
1425 || (!curbuf->b_p_bomb
1426 && tmpname == NULL
1427 && (*fenc == 'u' || (*fenc == NUL && enc_utf8)))))
1429 char_u *ccname;
1430 int blen;
1432 /* no BOM detection in a short file or in binary mode */
1433 if (size < 2 || curbuf->b_p_bin)
1434 ccname = NULL;
1435 else
1436 ccname = check_for_bom(ptr, size, &blen,
1437 fio_flags == FIO_UCSBOM ? FIO_ALL : get_fio_flags(fenc));
1438 if (ccname != NULL)
1440 /* Remove BOM from the text */
1441 filesize += blen;
1442 size -= blen;
1443 mch_memmove(ptr, ptr + blen, (size_t)size);
1444 if (set_options)
1446 curbuf->b_p_bomb = TRUE;
1447 curbuf->b_start_bomb = TRUE;
1451 if (fio_flags == FIO_UCSBOM)
1453 if (ccname == NULL)
1455 /* No BOM detected: retry with next encoding. */
1456 advance_fenc = TRUE;
1458 else
1460 /* BOM detected: set "fenc" and jump back */
1461 if (fenc_alloced)
1462 vim_free(fenc);
1463 fenc = ccname;
1464 fenc_alloced = FALSE;
1466 /* retry reading without getting new bytes or rewinding */
1467 skip_read = TRUE;
1468 goto retry;
1472 /* Include not converted bytes. */
1473 ptr -= conv_restlen;
1474 size += conv_restlen;
1475 conv_restlen = 0;
1476 #endif
1478 * Break here for a read error or end-of-file.
1480 if (size <= 0)
1481 break;
1483 #ifdef FEAT_MBYTE
1485 # ifdef USE_ICONV
1486 if (iconv_fd != (iconv_t)-1)
1489 * Attempt conversion of the read bytes to 'encoding' using
1490 * iconv().
1492 const char *fromp;
1493 char *top;
1494 size_t from_size;
1495 size_t to_size;
1497 fromp = (char *)ptr;
1498 from_size = size;
1499 ptr += size;
1500 top = (char *)ptr;
1501 to_size = real_size - size;
1504 * If there is conversion error or not enough room try using
1505 * another conversion. Except for when there is no
1506 * alternative (help files).
1508 while ((iconv(iconv_fd, (void *)&fromp, &from_size,
1509 &top, &to_size)
1510 == (size_t)-1 && ICONV_ERRNO != ICONV_EINVAL)
1511 || from_size > CONV_RESTLEN)
1513 if (can_retry)
1514 goto rewind_retry;
1515 if (conv_error == 0)
1516 conv_error = readfile_linenr(linecnt,
1517 ptr, (char_u *)top);
1519 /* Deal with a bad byte and continue with the next. */
1520 ++fromp;
1521 --from_size;
1522 if (bad_char_behavior == BAD_KEEP)
1524 *top++ = *(fromp - 1);
1525 --to_size;
1527 else if (bad_char_behavior != BAD_DROP)
1529 *top++ = bad_char_behavior;
1530 --to_size;
1534 if (from_size > 0)
1536 /* Some remaining characters, keep them for the next
1537 * round. */
1538 mch_memmove(conv_rest, (char_u *)fromp, from_size);
1539 conv_restlen = (int)from_size;
1542 /* move the linerest to before the converted characters */
1543 line_start = ptr - linerest;
1544 mch_memmove(line_start, buffer, (size_t)linerest);
1545 size = (long)((char_u *)top - ptr);
1547 # endif
1549 # ifdef WIN3264
1550 if (fio_flags & FIO_CODEPAGE)
1552 char_u *src, *dst;
1553 WCHAR ucs2buf[3];
1554 int ucs2len;
1555 int codepage = FIO_GET_CP(fio_flags);
1556 int bytelen;
1557 int found_bad;
1558 char replstr[2];
1561 * Conversion from an MS-Windows codepage or UTF-8 to UTF-8 or
1562 * a codepage, using standard MS-Windows functions. This
1563 * requires two steps:
1564 * 1. convert from 'fileencoding' to ucs-2
1565 * 2. convert from ucs-2 to 'encoding'
1567 * Because there may be illegal bytes AND an incomplete byte
1568 * sequence at the end, we may have to do the conversion one
1569 * character at a time to get it right.
1572 /* Replacement string for WideCharToMultiByte(). */
1573 if (bad_char_behavior > 0)
1574 replstr[0] = bad_char_behavior;
1575 else
1576 replstr[0] = '?';
1577 replstr[1] = NUL;
1580 * Move the bytes to the end of the buffer, so that we have
1581 * room to put the result at the start.
1583 src = ptr + real_size - size;
1584 mch_memmove(src, ptr, size);
1587 * Do the conversion.
1589 dst = ptr;
1590 size = size;
1591 while (size > 0)
1593 found_bad = FALSE;
1595 # ifdef CP_UTF8 /* VC 4.1 doesn't define CP_UTF8 */
1596 if (codepage == CP_UTF8)
1598 /* Handle CP_UTF8 input ourselves to be able to handle
1599 * trailing bytes properly.
1600 * Get one UTF-8 character from src. */
1601 bytelen = (int)utf_ptr2len_len(src, size);
1602 if (bytelen > size)
1604 /* Only got some bytes of a character. Normally
1605 * it's put in "conv_rest", but if it's too long
1606 * deal with it as if they were illegal bytes. */
1607 if (bytelen <= CONV_RESTLEN)
1608 break;
1610 /* weird overlong byte sequence */
1611 bytelen = size;
1612 found_bad = TRUE;
1614 else
1616 int u8c = utf_ptr2char(src);
1618 if (u8c > 0xffff || (*src >= 0x80 && bytelen == 1))
1619 found_bad = TRUE;
1620 ucs2buf[0] = u8c;
1621 ucs2len = 1;
1624 else
1625 # endif
1627 /* We don't know how long the byte sequence is, try
1628 * from one to three bytes. */
1629 for (bytelen = 1; bytelen <= size && bytelen <= 3;
1630 ++bytelen)
1632 ucs2len = MultiByteToWideChar(codepage,
1633 MB_ERR_INVALID_CHARS,
1634 (LPCSTR)src, bytelen,
1635 ucs2buf, 3);
1636 if (ucs2len > 0)
1637 break;
1639 if (ucs2len == 0)
1641 /* If we have only one byte then it's probably an
1642 * incomplete byte sequence. Otherwise discard
1643 * one byte as a bad character. */
1644 if (size == 1)
1645 break;
1646 found_bad = TRUE;
1647 bytelen = 1;
1651 if (!found_bad)
1653 int i;
1655 /* Convert "ucs2buf[ucs2len]" to 'enc' in "dst". */
1656 if (enc_utf8)
1658 /* From UCS-2 to UTF-8. Cannot fail. */
1659 for (i = 0; i < ucs2len; ++i)
1660 dst += utf_char2bytes(ucs2buf[i], dst);
1662 else
1664 BOOL bad = FALSE;
1665 int dstlen;
1667 /* From UCS-2 to "enc_codepage". If the
1668 * conversion uses the default character "?",
1669 * the data doesn't fit in this encoding. */
1670 dstlen = WideCharToMultiByte(enc_codepage, 0,
1671 (LPCWSTR)ucs2buf, ucs2len,
1672 (LPSTR)dst, (int)(src - dst),
1673 replstr, &bad);
1674 if (bad)
1675 found_bad = TRUE;
1676 else
1677 dst += dstlen;
1681 if (found_bad)
1683 /* Deal with bytes we can't convert. */
1684 if (can_retry)
1685 goto rewind_retry;
1686 if (conv_error == 0)
1687 conv_error = readfile_linenr(linecnt, ptr, dst);
1688 if (bad_char_behavior != BAD_DROP)
1690 if (bad_char_behavior == BAD_KEEP)
1692 mch_memmove(dst, src, bytelen);
1693 dst += bytelen;
1695 else
1696 *dst++ = bad_char_behavior;
1700 src += bytelen;
1701 size -= bytelen;
1704 if (size > 0)
1706 /* An incomplete byte sequence remaining. */
1707 mch_memmove(conv_rest, src, size);
1708 conv_restlen = size;
1711 /* The new size is equal to how much "dst" was advanced. */
1712 size = (long)(dst - ptr);
1714 else
1715 # endif
1716 # ifdef MACOS_CONVERT
1717 if (fio_flags & FIO_MACROMAN)
1720 * Conversion from Apple MacRoman char encoding to UTF-8 or
1721 * latin1. This is in os_mac_conv.c.
1723 if (macroman2enc(ptr, &size, real_size) == FAIL)
1724 goto rewind_retry;
1726 else
1727 # endif
1728 if (fio_flags != 0)
1730 int u8c;
1731 char_u *dest;
1732 char_u *tail = NULL;
1735 * "enc_utf8" set: Convert Unicode or Latin1 to UTF-8.
1736 * "enc_utf8" not set: Convert Unicode to Latin1.
1737 * Go from end to start through the buffer, because the number
1738 * of bytes may increase.
1739 * "dest" points to after where the UTF-8 bytes go, "p" points
1740 * to after the next character to convert.
1742 dest = ptr + real_size;
1743 if (fio_flags == FIO_LATIN1 || fio_flags == FIO_UTF8)
1745 p = ptr + size;
1746 if (fio_flags == FIO_UTF8)
1748 /* Check for a trailing incomplete UTF-8 sequence */
1749 tail = ptr + size - 1;
1750 while (tail > ptr && (*tail & 0xc0) == 0x80)
1751 --tail;
1752 if (tail + utf_byte2len(*tail) <= ptr + size)
1753 tail = NULL;
1754 else
1755 p = tail;
1758 else if (fio_flags & (FIO_UCS2 | FIO_UTF16))
1760 /* Check for a trailing byte */
1761 p = ptr + (size & ~1);
1762 if (size & 1)
1763 tail = p;
1764 if ((fio_flags & FIO_UTF16) && p > ptr)
1766 /* Check for a trailing leading word */
1767 if (fio_flags & FIO_ENDIAN_L)
1769 u8c = (*--p << 8);
1770 u8c += *--p;
1772 else
1774 u8c = *--p;
1775 u8c += (*--p << 8);
1777 if (u8c >= 0xd800 && u8c <= 0xdbff)
1778 tail = p;
1779 else
1780 p += 2;
1783 else /* FIO_UCS4 */
1785 /* Check for trailing 1, 2 or 3 bytes */
1786 p = ptr + (size & ~3);
1787 if (size & 3)
1788 tail = p;
1791 /* If there is a trailing incomplete sequence move it to
1792 * conv_rest[]. */
1793 if (tail != NULL)
1795 conv_restlen = (int)((ptr + size) - tail);
1796 mch_memmove(conv_rest, (char_u *)tail, conv_restlen);
1797 size -= conv_restlen;
1801 while (p > ptr)
1803 if (fio_flags & FIO_LATIN1)
1804 u8c = *--p;
1805 else if (fio_flags & (FIO_UCS2 | FIO_UTF16))
1807 if (fio_flags & FIO_ENDIAN_L)
1809 u8c = (*--p << 8);
1810 u8c += *--p;
1812 else
1814 u8c = *--p;
1815 u8c += (*--p << 8);
1817 if ((fio_flags & FIO_UTF16)
1818 && u8c >= 0xdc00 && u8c <= 0xdfff)
1820 int u16c;
1822 if (p == ptr)
1824 /* Missing leading word. */
1825 if (can_retry)
1826 goto rewind_retry;
1827 if (conv_error == 0)
1828 conv_error = readfile_linenr(linecnt,
1829 ptr, p);
1830 if (bad_char_behavior == BAD_DROP)
1831 continue;
1832 if (bad_char_behavior != BAD_KEEP)
1833 u8c = bad_char_behavior;
1836 /* found second word of double-word, get the first
1837 * word and compute the resulting character */
1838 if (fio_flags & FIO_ENDIAN_L)
1840 u16c = (*--p << 8);
1841 u16c += *--p;
1843 else
1845 u16c = *--p;
1846 u16c += (*--p << 8);
1848 u8c = 0x10000 + ((u16c & 0x3ff) << 10)
1849 + (u8c & 0x3ff);
1851 /* Check if the word is indeed a leading word. */
1852 if (u16c < 0xd800 || u16c > 0xdbff)
1854 if (can_retry)
1855 goto rewind_retry;
1856 if (conv_error == 0)
1857 conv_error = readfile_linenr(linecnt,
1858 ptr, p);
1859 if (bad_char_behavior == BAD_DROP)
1860 continue;
1861 if (bad_char_behavior != BAD_KEEP)
1862 u8c = bad_char_behavior;
1866 else if (fio_flags & FIO_UCS4)
1868 if (fio_flags & FIO_ENDIAN_L)
1870 u8c = (*--p << 24);
1871 u8c += (*--p << 16);
1872 u8c += (*--p << 8);
1873 u8c += *--p;
1875 else /* big endian */
1877 u8c = *--p;
1878 u8c += (*--p << 8);
1879 u8c += (*--p << 16);
1880 u8c += (*--p << 24);
1883 else /* UTF-8 */
1885 if (*--p < 0x80)
1886 u8c = *p;
1887 else
1889 len = utf_head_off(ptr, p);
1890 p -= len;
1891 u8c = utf_ptr2char(p);
1892 if (len == 0)
1894 /* Not a valid UTF-8 character, retry with
1895 * another fenc when possible, otherwise just
1896 * report the error. */
1897 if (can_retry)
1898 goto rewind_retry;
1899 if (conv_error == 0)
1900 conv_error = readfile_linenr(linecnt,
1901 ptr, p);
1902 if (bad_char_behavior == BAD_DROP)
1903 continue;
1904 if (bad_char_behavior != BAD_KEEP)
1905 u8c = bad_char_behavior;
1909 if (enc_utf8) /* produce UTF-8 */
1911 dest -= utf_char2len(u8c);
1912 (void)utf_char2bytes(u8c, dest);
1914 else /* produce Latin1 */
1916 --dest;
1917 if (u8c >= 0x100)
1919 /* character doesn't fit in latin1, retry with
1920 * another fenc when possible, otherwise just
1921 * report the error. */
1922 if (can_retry)
1923 goto rewind_retry;
1924 if (conv_error == 0)
1925 conv_error = readfile_linenr(linecnt, ptr, p);
1926 if (bad_char_behavior == BAD_DROP)
1927 ++dest;
1928 else if (bad_char_behavior == BAD_KEEP)
1929 *dest = u8c;
1930 else if (eap != NULL && eap->bad_char != 0)
1931 *dest = bad_char_behavior;
1932 else
1933 *dest = 0xBF;
1935 else
1936 *dest = u8c;
1940 /* move the linerest to before the converted characters */
1941 line_start = dest - linerest;
1942 mch_memmove(line_start, buffer, (size_t)linerest);
1943 size = (long)((ptr + real_size) - dest);
1944 ptr = dest;
1946 else if (enc_utf8 && !curbuf->b_p_bin)
1948 int incomplete_tail = FALSE;
1950 /* Reading UTF-8: Check if the bytes are valid UTF-8. */
1951 for (p = ptr; ; ++p)
1953 int todo = (int)((ptr + size) - p);
1954 int l;
1956 if (todo <= 0)
1957 break;
1958 if (*p >= 0x80)
1960 /* A length of 1 means it's an illegal byte. Accept
1961 * an incomplete character at the end though, the next
1962 * read() will get the next bytes, we'll check it
1963 * then. */
1964 l = utf_ptr2len_len(p, todo);
1965 if (l > todo && !incomplete_tail)
1967 /* Avoid retrying with a different encoding when
1968 * a truncated file is more likely, or attempting
1969 * to read the rest of an incomplete sequence when
1970 * we have already done so. */
1971 if (p > ptr || filesize > 0)
1972 incomplete_tail = TRUE;
1973 /* Incomplete byte sequence, move it to conv_rest[]
1974 * and try to read the rest of it, unless we've
1975 * already done so. */
1976 if (p > ptr)
1978 conv_restlen = todo;
1979 mch_memmove(conv_rest, p, conv_restlen);
1980 size -= conv_restlen;
1981 break;
1984 if (l == 1 || l > todo)
1986 /* Illegal byte. If we can try another encoding
1987 * do that, unless at EOF where a truncated
1988 * file is more likely than a conversion error. */
1989 if (can_retry && !incomplete_tail)
1990 break;
1991 # ifdef USE_ICONV
1992 /* When we did a conversion report an error. */
1993 if (iconv_fd != (iconv_t)-1 && conv_error == 0)
1994 conv_error = readfile_linenr(linecnt, ptr, p);
1995 # endif
1996 /* Remember the first linenr with an illegal byte */
1997 if (conv_error == 0 && illegal_byte == 0)
1998 illegal_byte = readfile_linenr(linecnt, ptr, p);
2000 /* Drop, keep or replace the bad byte. */
2001 if (bad_char_behavior == BAD_DROP)
2003 mch_memmove(p, p + 1, todo - 1);
2004 --p;
2005 --size;
2007 else if (bad_char_behavior != BAD_KEEP)
2008 *p = bad_char_behavior;
2010 else
2011 p += l - 1;
2014 if (p < ptr + size && !incomplete_tail)
2016 /* Detected a UTF-8 error. */
2017 rewind_retry:
2018 /* Retry reading with another conversion. */
2019 # if defined(FEAT_EVAL) && defined(USE_ICONV)
2020 if (*p_ccv != NUL && iconv_fd != (iconv_t)-1)
2021 /* iconv() failed, try 'charconvert' */
2022 did_iconv = TRUE;
2023 else
2024 # endif
2025 /* use next item from 'fileencodings' */
2026 advance_fenc = TRUE;
2027 file_rewind = TRUE;
2028 goto retry;
2031 #endif
2033 /* count the number of characters (after conversion!) */
2034 filesize += size;
2037 * when reading the first part of a file: guess EOL type
2039 if (fileformat == EOL_UNKNOWN)
2041 /* First try finding a NL, for Dos and Unix */
2042 if (try_dos || try_unix)
2044 for (p = ptr; p < ptr + size; ++p)
2046 if (*p == NL)
2048 if (!try_unix
2049 || (try_dos && p > ptr && p[-1] == CAR))
2050 fileformat = EOL_DOS;
2051 else
2052 fileformat = EOL_UNIX;
2053 break;
2057 /* Don't give in to EOL_UNIX if EOL_MAC is more likely */
2058 if (fileformat == EOL_UNIX && try_mac)
2060 /* Need to reset the counters when retrying fenc. */
2061 try_mac = 1;
2062 try_unix = 1;
2063 for (; p >= ptr && *p != CAR; p--)
2065 if (p >= ptr)
2067 for (p = ptr; p < ptr + size; ++p)
2069 if (*p == NL)
2070 try_unix++;
2071 else if (*p == CAR)
2072 try_mac++;
2074 if (try_mac > try_unix)
2075 fileformat = EOL_MAC;
2080 /* No NL found: may use Mac format */
2081 if (fileformat == EOL_UNKNOWN && try_mac)
2082 fileformat = EOL_MAC;
2084 /* Still nothing found? Use first format in 'ffs' */
2085 if (fileformat == EOL_UNKNOWN)
2086 fileformat = default_fileformat();
2088 /* if editing a new file: may set p_tx and p_ff */
2089 if (set_options)
2090 set_fileformat(fileformat, OPT_LOCAL);
2095 * This loop is executed once for every character read.
2096 * Keep it fast!
2098 if (fileformat == EOL_MAC)
2100 --ptr;
2101 while (++ptr, --size >= 0)
2103 /* catch most common case first */
2104 if ((c = *ptr) != NUL && c != CAR && c != NL)
2105 continue;
2106 if (c == NUL)
2107 *ptr = NL; /* NULs are replaced by newlines! */
2108 else if (c == NL)
2109 *ptr = CAR; /* NLs are replaced by CRs! */
2110 else
2112 if (skip_count == 0)
2114 *ptr = NUL; /* end of line */
2115 len = (colnr_T) (ptr - line_start + 1);
2116 if (ml_append(lnum, line_start, len, newfile) == FAIL)
2118 error = TRUE;
2119 break;
2121 ++lnum;
2122 if (--read_count == 0)
2124 error = TRUE; /* break loop */
2125 line_start = ptr; /* nothing left to write */
2126 break;
2129 else
2130 --skip_count;
2131 line_start = ptr + 1;
2135 else
2137 --ptr;
2138 while (++ptr, --size >= 0)
2140 if ((c = *ptr) != NUL && c != NL) /* catch most common case */
2141 continue;
2142 if (c == NUL)
2143 *ptr = NL; /* NULs are replaced by newlines! */
2144 else
2146 if (skip_count == 0)
2148 *ptr = NUL; /* end of line */
2149 len = (colnr_T)(ptr - line_start + 1);
2150 if (fileformat == EOL_DOS)
2152 if (ptr[-1] == CAR) /* remove CR */
2154 ptr[-1] = NUL;
2155 --len;
2158 * Reading in Dos format, but no CR-LF found!
2159 * When 'fileformats' includes "unix", delete all
2160 * the lines read so far and start all over again.
2161 * Otherwise give an error message later.
2163 else if (ff_error != EOL_DOS)
2165 if ( try_unix
2166 && !read_stdin
2167 && (read_buffer
2168 || lseek(fd, (off_t)0L, SEEK_SET) == 0))
2170 fileformat = EOL_UNIX;
2171 if (set_options)
2172 set_fileformat(EOL_UNIX, OPT_LOCAL);
2173 file_rewind = TRUE;
2174 keep_fileformat = TRUE;
2175 goto retry;
2177 ff_error = EOL_DOS;
2180 if (ml_append(lnum, line_start, len, newfile) == FAIL)
2182 error = TRUE;
2183 break;
2185 ++lnum;
2186 if (--read_count == 0)
2188 error = TRUE; /* break loop */
2189 line_start = ptr; /* nothing left to write */
2190 break;
2193 else
2194 --skip_count;
2195 line_start = ptr + 1;
2199 linerest = (long)(ptr - line_start);
2200 ui_breakcheck();
2203 failed:
2204 /* not an error, max. number of lines reached */
2205 if (error && read_count == 0)
2206 error = FALSE;
2209 * If we get EOF in the middle of a line, note the fact and
2210 * complete the line ourselves.
2211 * In Dos format ignore a trailing CTRL-Z, unless 'binary' set.
2213 if (!error
2214 && !got_int
2215 && linerest != 0
2216 && !(!curbuf->b_p_bin
2217 && fileformat == EOL_DOS
2218 && *line_start == Ctrl_Z
2219 && ptr == line_start + 1))
2221 /* remember for when writing */
2222 if (set_options)
2223 curbuf->b_p_eol = FALSE;
2224 *ptr = NUL;
2225 if (ml_append(lnum, line_start,
2226 (colnr_T)(ptr - line_start + 1), newfile) == FAIL)
2227 error = TRUE;
2228 else
2229 read_no_eol_lnum = ++lnum;
2232 if (set_options)
2233 save_file_ff(curbuf); /* remember the current file format */
2235 #ifdef FEAT_CRYPT
2236 if (cryptkey != curbuf->b_p_key)
2237 vim_free(cryptkey);
2238 #endif
2240 #ifdef FEAT_MBYTE
2241 /* If editing a new file: set 'fenc' for the current buffer.
2242 * Also for ":read ++edit file". */
2243 if (set_options)
2244 set_string_option_direct((char_u *)"fenc", -1, fenc,
2245 OPT_FREE|OPT_LOCAL, 0);
2246 if (fenc_alloced)
2247 vim_free(fenc);
2248 # ifdef USE_ICONV
2249 if (iconv_fd != (iconv_t)-1)
2251 iconv_close(iconv_fd);
2252 iconv_fd = (iconv_t)-1;
2254 # endif
2255 #endif
2257 if (!read_buffer && !read_stdin)
2258 close(fd); /* errors are ignored */
2259 #ifdef HAVE_FD_CLOEXEC
2260 else
2262 int fdflags = fcntl(fd, F_GETFD);
2263 if (fdflags >= 0 && (fdflags & FD_CLOEXEC) == 0)
2264 fcntl(fd, F_SETFD, fdflags | FD_CLOEXEC);
2266 #endif
2267 vim_free(buffer);
2269 #ifdef HAVE_DUP
2270 if (read_stdin)
2272 /* Use stderr for stdin, makes shell commands work. */
2273 close(0);
2274 ignored = dup(2);
2276 #endif
2278 #ifdef FEAT_MBYTE
2279 if (tmpname != NULL)
2281 mch_remove(tmpname); /* delete converted file */
2282 vim_free(tmpname);
2284 #endif
2285 --no_wait_return; /* may wait for return now */
2288 * In recovery mode everything but autocommands is skipped.
2290 if (!recoverymode)
2292 /* need to delete the last line, which comes from the empty buffer */
2293 if (newfile && wasempty && !(curbuf->b_ml.ml_flags & ML_EMPTY))
2295 #ifdef FEAT_NETBEANS_INTG
2296 netbeansFireChanges = 0;
2297 #endif
2298 ml_delete(curbuf->b_ml.ml_line_count, FALSE);
2299 #ifdef FEAT_NETBEANS_INTG
2300 netbeansFireChanges = 1;
2301 #endif
2302 --linecnt;
2304 linecnt = curbuf->b_ml.ml_line_count - linecnt;
2305 if (filesize == 0)
2306 linecnt = 0;
2307 if (newfile || read_buffer)
2309 redraw_curbuf_later(NOT_VALID);
2310 #ifdef FEAT_DIFF
2311 /* After reading the text into the buffer the diff info needs to
2312 * be updated. */
2313 diff_invalidate(curbuf);
2314 #endif
2315 #ifdef FEAT_FOLDING
2316 /* All folds in the window are invalid now. Mark them for update
2317 * before triggering autocommands. */
2318 foldUpdateAll(curwin);
2319 #endif
2321 else if (linecnt) /* appended at least one line */
2322 appended_lines_mark(from, linecnt);
2324 #ifndef ALWAYS_USE_GUI
2326 * If we were reading from the same terminal as where messages go,
2327 * the screen will have been messed up.
2328 * Switch on raw mode now and clear the screen.
2330 if (read_stdin)
2332 settmode(TMODE_RAW); /* set to raw mode */
2333 starttermcap();
2334 screenclear();
2336 #endif
2338 if (got_int)
2340 if (!(flags & READ_DUMMY))
2342 filemess(curbuf, sfname, (char_u *)_(e_interr), 0);
2343 if (newfile)
2344 curbuf->b_p_ro = TRUE; /* must use "w!" now */
2346 msg_scroll = msg_save;
2347 #ifdef FEAT_VIMINFO
2348 check_marks_read();
2349 #endif
2350 return OK; /* an interrupt isn't really an error */
2353 if (!filtering && !(flags & READ_DUMMY))
2355 msg_add_fname(curbuf, sfname); /* fname in IObuff with quotes */
2356 c = FALSE;
2358 #ifdef UNIX
2359 # ifdef S_ISFIFO
2360 if (S_ISFIFO(perm)) /* fifo or socket */
2362 STRCAT(IObuff, _("[fifo/socket]"));
2363 c = TRUE;
2365 # else
2366 # ifdef S_IFIFO
2367 if ((perm & S_IFMT) == S_IFIFO) /* fifo */
2369 STRCAT(IObuff, _("[fifo]"));
2370 c = TRUE;
2372 # endif
2373 # ifdef S_IFSOCK
2374 if ((perm & S_IFMT) == S_IFSOCK) /* or socket */
2376 STRCAT(IObuff, _("[socket]"));
2377 c = TRUE;
2379 # endif
2380 # endif
2381 # ifdef OPEN_CHR_FILES
2382 if (S_ISCHR(perm)) /* or character special */
2384 STRCAT(IObuff, _("[character special]"));
2385 c = TRUE;
2387 # endif
2388 #endif
2389 if (curbuf->b_p_ro)
2391 STRCAT(IObuff, shortmess(SHM_RO) ? _("[RO]") : _("[readonly]"));
2392 c = TRUE;
2394 if (read_no_eol_lnum)
2396 msg_add_eol();
2397 c = TRUE;
2399 if (ff_error == EOL_DOS)
2401 STRCAT(IObuff, _("[CR missing]"));
2402 c = TRUE;
2404 if (split)
2406 STRCAT(IObuff, _("[long lines split]"));
2407 c = TRUE;
2409 #ifdef FEAT_MBYTE
2410 if (notconverted)
2412 STRCAT(IObuff, _("[NOT converted]"));
2413 c = TRUE;
2415 else if (converted)
2417 STRCAT(IObuff, _("[converted]"));
2418 c = TRUE;
2420 #endif
2421 #ifdef FEAT_CRYPT
2422 if (cryptkey != NULL)
2424 STRCAT(IObuff, _("[crypted]"));
2425 c = TRUE;
2427 #endif
2428 #ifdef FEAT_MBYTE
2429 if (conv_error != 0)
2431 sprintf((char *)IObuff + STRLEN(IObuff),
2432 _("[CONVERSION ERROR in line %ld]"), (long)conv_error);
2433 c = TRUE;
2435 else if (illegal_byte > 0)
2437 sprintf((char *)IObuff + STRLEN(IObuff),
2438 _("[ILLEGAL BYTE in line %ld]"), (long)illegal_byte);
2439 c = TRUE;
2441 else
2442 #endif
2443 if (error)
2445 STRCAT(IObuff, _("[READ ERRORS]"));
2446 c = TRUE;
2448 if (msg_add_fileformat(fileformat))
2449 c = TRUE;
2450 #ifdef FEAT_CRYPT
2451 if (cryptkey != NULL)
2452 msg_add_lines(c, (long)linecnt, filesize - CRYPT_MAGIC_LEN);
2453 else
2454 #endif
2455 msg_add_lines(c, (long)linecnt, filesize);
2457 vim_free(keep_msg);
2458 keep_msg = NULL;
2459 msg_scrolled_ign = TRUE;
2460 #ifdef ALWAYS_USE_GUI
2461 /* Don't show the message when reading stdin, it would end up in a
2462 * message box (which might be shown when exiting!) */
2463 if (read_stdin || read_buffer)
2464 p = msg_may_trunc(FALSE, IObuff);
2465 else
2466 #endif
2467 p = msg_trunc_attr(IObuff, FALSE, 0);
2468 if (read_stdin || read_buffer || restart_edit != 0
2469 || (msg_scrolled != 0 && !need_wait_return))
2470 /* Need to repeat the message after redrawing when:
2471 * - When reading from stdin (the screen will be cleared next).
2472 * - When restart_edit is set (otherwise there will be a delay
2473 * before redrawing).
2474 * - When the screen was scrolled but there is no wait-return
2475 * prompt. */
2476 set_keep_msg(p, 0);
2477 msg_scrolled_ign = FALSE;
2480 /* with errors writing the file requires ":w!" */
2481 if (newfile && (error
2482 #ifdef FEAT_MBYTE
2483 || conv_error != 0
2484 || (illegal_byte > 0 && bad_char_behavior != BAD_KEEP)
2485 #endif
2487 curbuf->b_p_ro = TRUE;
2489 u_clearline(); /* cannot use "U" command after adding lines */
2492 * In Ex mode: cursor at last new line.
2493 * Otherwise: cursor at first new line.
2495 if (exmode_active)
2496 curwin->w_cursor.lnum = from + linecnt;
2497 else
2498 curwin->w_cursor.lnum = from + 1;
2499 check_cursor_lnum();
2500 beginline(BL_WHITE | BL_FIX); /* on first non-blank */
2503 * Set '[ and '] marks to the newly read lines.
2505 curbuf->b_op_start.lnum = from + 1;
2506 curbuf->b_op_start.col = 0;
2507 curbuf->b_op_end.lnum = from + linecnt;
2508 curbuf->b_op_end.col = 0;
2510 #ifdef WIN32
2512 * Work around a weird problem: When a file has two links (only
2513 * possible on NTFS) and we write through one link, then stat() it
2514 * through the other link, the timestamp information may be wrong.
2515 * It's correct again after reading the file, thus reset the timestamp
2516 * here.
2518 if (newfile && !read_stdin && !read_buffer
2519 && mch_stat((char *)fname, &st) >= 0)
2521 buf_store_time(curbuf, &st, fname);
2522 curbuf->b_mtime_read = curbuf->b_mtime;
2524 #endif
2526 msg_scroll = msg_save;
2528 #ifdef FEAT_VIMINFO
2530 * Get the marks before executing autocommands, so they can be used there.
2532 check_marks_read();
2533 #endif
2536 * Trick: We remember if the last line of the read didn't have
2537 * an eol for when writing it again. This is required for
2538 * ":autocmd FileReadPost *.gz set bin|'[,']!gunzip" to work.
2540 write_no_eol_lnum = read_no_eol_lnum;
2542 #ifdef FEAT_AUTOCMD
2543 if (!read_stdin && !read_buffer)
2545 int m = msg_scroll;
2546 int n = msg_scrolled;
2548 /* Save the fileformat now, otherwise the buffer will be considered
2549 * modified if the format/encoding was automatically detected. */
2550 if (set_options)
2551 save_file_ff(curbuf);
2554 * The output from the autocommands should not overwrite anything and
2555 * should not be overwritten: Set msg_scroll, restore its value if no
2556 * output was done.
2558 msg_scroll = TRUE;
2559 if (filtering)
2560 apply_autocmds_exarg(EVENT_FILTERREADPOST, NULL, sfname,
2561 FALSE, curbuf, eap);
2562 else if (newfile)
2563 apply_autocmds_exarg(EVENT_BUFREADPOST, NULL, sfname,
2564 FALSE, curbuf, eap);
2565 else
2566 apply_autocmds_exarg(EVENT_FILEREADPOST, sfname, sfname,
2567 FALSE, NULL, eap);
2568 if (msg_scrolled == n)
2569 msg_scroll = m;
2570 #ifdef FEAT_EVAL
2571 if (aborting()) /* autocmds may abort script processing */
2572 return FAIL;
2573 #endif
2575 #endif
2577 if (recoverymode && error)
2578 return FAIL;
2579 return OK;
2582 #ifdef OPEN_CHR_FILES
2584 * Returns TRUE if the file name argument is of the form "/dev/fd/\d\+",
2585 * which is the name of files used for process substitution output by
2586 * some shells on some operating systems, e.g., bash on SunOS.
2587 * Do not accept "/dev/fd/[012]", opening these may hang Vim.
2589 static int
2590 is_dev_fd_file(fname)
2591 char_u *fname;
2593 return (STRNCMP(fname, "/dev/fd/", 8) == 0
2594 && VIM_ISDIGIT(fname[8])
2595 && *skipdigits(fname + 9) == NUL
2596 && (fname[9] != NUL
2597 || (fname[8] != '0' && fname[8] != '1' && fname[8] != '2')));
2599 #endif
2601 #ifdef FEAT_MBYTE
2604 * From the current line count and characters read after that, estimate the
2605 * line number where we are now.
2606 * Used for error messages that include a line number.
2608 static linenr_T
2609 readfile_linenr(linecnt, p, endp)
2610 linenr_T linecnt; /* line count before reading more bytes */
2611 char_u *p; /* start of more bytes read */
2612 char_u *endp; /* end of more bytes read */
2614 char_u *s;
2615 linenr_T lnum;
2617 lnum = curbuf->b_ml.ml_line_count - linecnt + 1;
2618 for (s = p; s < endp; ++s)
2619 if (*s == '\n')
2620 ++lnum;
2621 return lnum;
2623 #endif
2626 * Fill "*eap" to force the 'fileencoding', 'fileformat' and 'binary to be
2627 * equal to the buffer "buf". Used for calling readfile().
2628 * Returns OK or FAIL.
2631 prep_exarg(eap, buf)
2632 exarg_T *eap;
2633 buf_T *buf;
2635 eap->cmd = alloc((unsigned)(STRLEN(buf->b_p_ff)
2636 #ifdef FEAT_MBYTE
2637 + STRLEN(buf->b_p_fenc)
2638 #endif
2639 + 15));
2640 if (eap->cmd == NULL)
2641 return FAIL;
2643 #ifdef FEAT_MBYTE
2644 sprintf((char *)eap->cmd, "e ++ff=%s ++enc=%s", buf->b_p_ff, buf->b_p_fenc);
2645 eap->force_enc = 14 + (int)STRLEN(buf->b_p_ff);
2646 eap->bad_char = buf->b_bad_char;
2647 #else
2648 sprintf((char *)eap->cmd, "e ++ff=%s", buf->b_p_ff);
2649 #endif
2650 eap->force_ff = 7;
2652 eap->force_bin = buf->b_p_bin ? FORCE_BIN : FORCE_NOBIN;
2653 eap->read_edit = FALSE;
2654 eap->forceit = FALSE;
2655 return OK;
2658 #ifdef FEAT_MBYTE
2660 * Find next fileencoding to use from 'fileencodings'.
2661 * "pp" points to fenc_next. It's advanced to the next item.
2662 * When there are no more items, an empty string is returned and *pp is set to
2663 * NULL.
2664 * When *pp is not set to NULL, the result is in allocated memory.
2666 static char_u *
2667 next_fenc(pp)
2668 char_u **pp;
2670 char_u *p;
2671 char_u *r;
2673 if (**pp == NUL)
2675 *pp = NULL;
2676 return (char_u *)"";
2678 p = vim_strchr(*pp, ',');
2679 if (p == NULL)
2681 r = enc_canonize(*pp);
2682 *pp += STRLEN(*pp);
2684 else
2686 r = vim_strnsave(*pp, (int)(p - *pp));
2687 *pp = p + 1;
2688 if (r != NULL)
2690 p = enc_canonize(r);
2691 vim_free(r);
2692 r = p;
2695 if (r == NULL) /* out of memory */
2697 r = (char_u *)"";
2698 *pp = NULL;
2700 return r;
2703 # ifdef FEAT_EVAL
2705 * Convert a file with the 'charconvert' expression.
2706 * This closes the file which is to be read, converts it and opens the
2707 * resulting file for reading.
2708 * Returns name of the resulting converted file (the caller should delete it
2709 * after reading it).
2710 * Returns NULL if the conversion failed ("*fdp" is not set) .
2712 static char_u *
2713 readfile_charconvert(fname, fenc, fdp)
2714 char_u *fname; /* name of input file */
2715 char_u *fenc; /* converted from */
2716 int *fdp; /* in/out: file descriptor of file */
2718 char_u *tmpname;
2719 char_u *errmsg = NULL;
2721 tmpname = vim_tempname('r');
2722 if (tmpname == NULL)
2723 errmsg = (char_u *)_("Can't find temp file for conversion");
2724 else
2726 close(*fdp); /* close the input file, ignore errors */
2727 *fdp = -1;
2728 if (eval_charconvert(fenc, enc_utf8 ? (char_u *)"utf-8" : p_enc,
2729 fname, tmpname) == FAIL)
2730 errmsg = (char_u *)_("Conversion with 'charconvert' failed");
2731 if (errmsg == NULL && (*fdp = mch_open((char *)tmpname,
2732 O_RDONLY | O_EXTRA, 0)) < 0)
2733 errmsg = (char_u *)_("can't read output of 'charconvert'");
2736 if (errmsg != NULL)
2738 /* Don't use emsg(), it breaks mappings, the retry with
2739 * another type of conversion might still work. */
2740 MSG(errmsg);
2741 if (tmpname != NULL)
2743 mch_remove(tmpname); /* delete converted file */
2744 vim_free(tmpname);
2745 tmpname = NULL;
2749 /* If the input file is closed, open it (caller should check for error). */
2750 if (*fdp < 0)
2751 *fdp = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
2753 return tmpname;
2755 # endif
2757 #endif
2759 #ifdef FEAT_VIMINFO
2761 * Read marks for the current buffer from the viminfo file, when we support
2762 * buffer marks and the buffer has a name.
2764 static void
2765 check_marks_read()
2767 if (!curbuf->b_marks_read && get_viminfo_parameter('\'') > 0
2768 && curbuf->b_ffname != NULL)
2769 read_viminfo(NULL, VIF_WANT_MARKS);
2771 /* Always set b_marks_read; needed when 'viminfo' is changed to include
2772 * the ' parameter after opening a buffer. */
2773 curbuf->b_marks_read = TRUE;
2775 #endif
2777 #ifdef FEAT_CRYPT
2779 * Check for magic number used for encryption.
2780 * If found, the magic number is removed from ptr[*sizep] and *sizep and
2781 * *filesizep are updated.
2782 * Return the (new) encryption key, NULL for no encryption.
2784 static char_u *
2785 check_for_cryptkey(cryptkey, ptr, sizep, filesizep, newfile)
2786 char_u *cryptkey; /* previous encryption key or NULL */
2787 char_u *ptr; /* pointer to read bytes */
2788 long *sizep; /* length of read bytes */
2789 long *filesizep; /* nr of bytes used from file */
2790 int newfile; /* editing a new buffer */
2792 if (*sizep >= CRYPT_MAGIC_LEN
2793 && STRNCMP(ptr, CRYPT_MAGIC, CRYPT_MAGIC_LEN) == 0)
2795 if (cryptkey == NULL)
2797 if (*curbuf->b_p_key)
2798 cryptkey = curbuf->b_p_key;
2799 else
2801 /* When newfile is TRUE, store the typed key
2802 * in the 'key' option and don't free it. */
2803 cryptkey = get_crypt_key(newfile, FALSE);
2804 /* check if empty key entered */
2805 if (cryptkey != NULL && *cryptkey == NUL)
2807 if (cryptkey != curbuf->b_p_key)
2808 vim_free(cryptkey);
2809 cryptkey = NULL;
2814 if (cryptkey != NULL)
2816 crypt_init_keys(cryptkey);
2818 /* Remove magic number from the text */
2819 *filesizep += CRYPT_MAGIC_LEN;
2820 *sizep -= CRYPT_MAGIC_LEN;
2821 mch_memmove(ptr, ptr + CRYPT_MAGIC_LEN, (size_t)*sizep);
2824 /* When starting to edit a new file which does not have
2825 * encryption, clear the 'key' option, except when
2826 * starting up (called with -x argument) */
2827 else if (newfile && *curbuf->b_p_key && !starting)
2828 set_option_value((char_u *)"key", 0L, (char_u *)"", OPT_LOCAL);
2830 return cryptkey;
2832 #endif
2834 #ifdef UNIX
2835 static void
2836 set_file_time(fname, atime, mtime)
2837 char_u *fname;
2838 time_t atime; /* access time */
2839 time_t mtime; /* modification time */
2841 # if defined(HAVE_UTIME) && defined(HAVE_UTIME_H)
2842 struct utimbuf buf;
2844 buf.actime = atime;
2845 buf.modtime = mtime;
2846 (void)utime((char *)fname, &buf);
2847 # else
2848 # if defined(HAVE_UTIMES)
2849 struct timeval tvp[2];
2851 tvp[0].tv_sec = atime;
2852 tvp[0].tv_usec = 0;
2853 tvp[1].tv_sec = mtime;
2854 tvp[1].tv_usec = 0;
2855 # ifdef NeXT
2856 (void)utimes((char *)fname, tvp);
2857 # else
2858 (void)utimes((char *)fname, (const struct timeval *)&tvp);
2859 # endif
2860 # endif
2861 # endif
2863 #endif /* UNIX */
2865 #if defined(VMS) && !defined(MIN)
2866 /* Older DECC compiler for VAX doesn't define MIN() */
2867 # define MIN(a, b) ((a) < (b) ? (a) : (b))
2868 #endif
2871 * Return TRUE if a file appears to be read-only from the file permissions.
2874 check_file_readonly(fname, perm)
2875 char_u *fname; /* full path to file */
2876 int perm; /* known permissions on file */
2878 #ifndef USE_MCH_ACCESS
2879 int fd = 0;
2880 #endif
2882 return (
2883 #ifdef USE_MCH_ACCESS
2884 # ifdef UNIX
2885 (perm & 0222) == 0 ||
2886 # endif
2887 mch_access((char *)fname, W_OK)
2888 #else
2889 (fd = mch_open((char *)fname, O_RDWR | O_EXTRA, 0)) < 0
2890 ? TRUE : (close(fd), FALSE)
2891 #endif
2897 * buf_write() - write to file "fname" lines "start" through "end"
2899 * We do our own buffering here because fwrite() is so slow.
2901 * If "forceit" is true, we don't care for errors when attempting backups.
2902 * In case of an error everything possible is done to restore the original
2903 * file. But when "forceit" is TRUE, we risk losing it.
2905 * When "reset_changed" is TRUE and "append" == FALSE and "start" == 1 and
2906 * "end" == curbuf->b_ml.ml_line_count, reset curbuf->b_changed.
2908 * This function must NOT use NameBuff (because it's called by autowrite()).
2910 * return FAIL for failure, OK otherwise
2913 buf_write(buf, fname, sfname, start, end, eap, append, forceit,
2914 reset_changed, filtering)
2915 buf_T *buf;
2916 char_u *fname;
2917 char_u *sfname;
2918 linenr_T start, end;
2919 exarg_T *eap; /* for forced 'ff' and 'fenc', can be
2920 NULL! */
2921 int append; /* append to the file */
2922 int forceit;
2923 int reset_changed;
2924 int filtering;
2926 int fd;
2927 char_u *backup = NULL;
2928 int backup_copy = FALSE; /* copy the original file? */
2929 int dobackup;
2930 char_u *ffname;
2931 char_u *wfname = NULL; /* name of file to write to */
2932 char_u *s;
2933 char_u *ptr;
2934 char_u c;
2935 int len;
2936 linenr_T lnum;
2937 long nchars;
2938 char_u *errmsg = NULL;
2939 int errmsg_allocated = FALSE;
2940 char_u *errnum = NULL;
2941 char_u *buffer;
2942 char_u smallbuf[SMBUFSIZE];
2943 char_u *backup_ext;
2944 int bufsize;
2945 long perm; /* file permissions */
2946 int retval = OK;
2947 int newfile = FALSE; /* TRUE if file doesn't exist yet */
2948 int msg_save = msg_scroll;
2949 int overwriting; /* TRUE if writing over original */
2950 int no_eol = FALSE; /* no end-of-line written */
2951 int device = FALSE; /* writing to a device */
2952 struct stat st_old;
2953 int prev_got_int = got_int;
2954 int file_readonly = FALSE; /* overwritten file is read-only */
2955 static char *err_readonly = "is read-only (cannot override: \"W\" in 'cpoptions')";
2956 #if defined(UNIX) || defined(__EMX__XX) /*XXX fix me sometime? */
2957 int made_writable = FALSE; /* 'w' bit has been set */
2958 #endif
2959 /* writing everything */
2960 int whole = (start == 1 && end == buf->b_ml.ml_line_count);
2961 #ifdef FEAT_AUTOCMD
2962 linenr_T old_line_count = buf->b_ml.ml_line_count;
2963 #endif
2964 int attr;
2965 int fileformat;
2966 int write_bin;
2967 struct bw_info write_info; /* info for buf_write_bytes() */
2968 #ifdef FEAT_MBYTE
2969 int converted = FALSE;
2970 int notconverted = FALSE;
2971 char_u *fenc; /* effective 'fileencoding' */
2972 char_u *fenc_tofree = NULL; /* allocated "fenc" */
2973 #endif
2974 #ifdef HAS_BW_FLAGS
2975 int wb_flags = 0;
2976 #endif
2977 #ifdef HAVE_ACL
2978 vim_acl_T acl = NULL; /* ACL copied from original file to
2979 backup or new file */
2980 #endif
2982 if (fname == NULL || *fname == NUL) /* safety check */
2983 return FAIL;
2984 if (buf->b_ml.ml_mfp == NULL)
2986 /* This can happen during startup when there is a stray "w" in the
2987 * vimrc file. */
2988 EMSG(_(e_emptybuf));
2989 return FAIL;
2993 * Disallow writing from .exrc and .vimrc in current directory for
2994 * security reasons.
2996 if (check_secure())
2997 return FAIL;
2999 /* Avoid a crash for a long name. */
3000 if (STRLEN(fname) >= MAXPATHL)
3002 EMSG(_(e_longname));
3003 return FAIL;
3006 #ifdef FEAT_MBYTE
3007 /* must init bw_conv_buf and bw_iconv_fd before jumping to "fail" */
3008 write_info.bw_conv_buf = NULL;
3009 write_info.bw_conv_error = FALSE;
3010 write_info.bw_conv_error_lnum = 0;
3011 write_info.bw_restlen = 0;
3012 # ifdef USE_ICONV
3013 write_info.bw_iconv_fd = (iconv_t)-1;
3014 # endif
3015 #endif
3017 /* After writing a file changedtick changes but we don't want to display
3018 * the line. */
3019 ex_no_reprint = TRUE;
3022 * If there is no file name yet, use the one for the written file.
3023 * BF_NOTEDITED is set to reflect this (in case the write fails).
3024 * Don't do this when the write is for a filter command.
3025 * Don't do this when appending.
3026 * Only do this when 'cpoptions' contains the 'F' flag.
3028 if (buf->b_ffname == NULL
3029 && reset_changed
3030 && whole
3031 && buf == curbuf
3032 #ifdef FEAT_QUICKFIX
3033 && !bt_nofile(buf)
3034 #endif
3035 && !filtering
3036 && (!append || vim_strchr(p_cpo, CPO_FNAMEAPP) != NULL)
3037 && vim_strchr(p_cpo, CPO_FNAMEW) != NULL)
3039 if (set_rw_fname(fname, sfname) == FAIL)
3040 return FAIL;
3041 buf = curbuf; /* just in case autocmds made "buf" invalid */
3044 if (sfname == NULL)
3045 sfname = fname;
3047 * For Unix: Use the short file name whenever possible.
3048 * Avoids problems with networks and when directory names are changed.
3049 * Don't do this for MS-DOS, a "cd" in a sub-shell may have moved us to
3050 * another directory, which we don't detect
3052 ffname = fname; /* remember full fname */
3053 #ifdef UNIX
3054 fname = sfname;
3055 #endif
3057 if (buf->b_ffname != NULL && fnamecmp(ffname, buf->b_ffname) == 0)
3058 overwriting = TRUE;
3059 else
3060 overwriting = FALSE;
3062 if (exiting)
3063 settmode(TMODE_COOK); /* when exiting allow typahead now */
3065 ++no_wait_return; /* don't wait for return yet */
3068 * Set '[ and '] marks to the lines to be written.
3070 buf->b_op_start.lnum = start;
3071 buf->b_op_start.col = 0;
3072 buf->b_op_end.lnum = end;
3073 buf->b_op_end.col = 0;
3075 #ifdef FEAT_AUTOCMD
3077 aco_save_T aco;
3078 int buf_ffname = FALSE;
3079 int buf_sfname = FALSE;
3080 int buf_fname_f = FALSE;
3081 int buf_fname_s = FALSE;
3082 int did_cmd = FALSE;
3083 int nofile_err = FALSE;
3084 int empty_memline = (buf->b_ml.ml_mfp == NULL);
3087 * Apply PRE aucocommands.
3088 * Set curbuf to the buffer to be written.
3089 * Careful: The autocommands may call buf_write() recursively!
3091 if (ffname == buf->b_ffname)
3092 buf_ffname = TRUE;
3093 if (sfname == buf->b_sfname)
3094 buf_sfname = TRUE;
3095 if (fname == buf->b_ffname)
3096 buf_fname_f = TRUE;
3097 if (fname == buf->b_sfname)
3098 buf_fname_s = TRUE;
3100 /* set curwin/curbuf to buf and save a few things */
3101 aucmd_prepbuf(&aco, buf);
3103 if (append)
3105 if (!(did_cmd = apply_autocmds_exarg(EVENT_FILEAPPENDCMD,
3106 sfname, sfname, FALSE, curbuf, eap)))
3108 #ifdef FEAT_QUICKFIX
3109 if (overwriting && bt_nofile(curbuf))
3110 nofile_err = TRUE;
3111 else
3112 #endif
3113 apply_autocmds_exarg(EVENT_FILEAPPENDPRE,
3114 sfname, sfname, FALSE, curbuf, eap);
3117 else if (filtering)
3119 apply_autocmds_exarg(EVENT_FILTERWRITEPRE,
3120 NULL, sfname, FALSE, curbuf, eap);
3122 else if (reset_changed && whole)
3124 if (!(did_cmd = apply_autocmds_exarg(EVENT_BUFWRITECMD,
3125 sfname, sfname, FALSE, curbuf, eap)))
3127 #ifdef FEAT_QUICKFIX
3128 if (overwriting && bt_nofile(curbuf))
3129 nofile_err = TRUE;
3130 else
3131 #endif
3132 apply_autocmds_exarg(EVENT_BUFWRITEPRE,
3133 sfname, sfname, FALSE, curbuf, eap);
3136 else
3138 if (!(did_cmd = apply_autocmds_exarg(EVENT_FILEWRITECMD,
3139 sfname, sfname, FALSE, curbuf, eap)))
3141 #ifdef FEAT_QUICKFIX
3142 if (overwriting && bt_nofile(curbuf))
3143 nofile_err = TRUE;
3144 else
3145 #endif
3146 apply_autocmds_exarg(EVENT_FILEWRITEPRE,
3147 sfname, sfname, FALSE, curbuf, eap);
3151 /* restore curwin/curbuf and a few other things */
3152 aucmd_restbuf(&aco);
3155 * In three situations we return here and don't write the file:
3156 * 1. the autocommands deleted or unloaded the buffer.
3157 * 2. The autocommands abort script processing.
3158 * 3. If one of the "Cmd" autocommands was executed.
3160 if (!buf_valid(buf))
3161 buf = NULL;
3162 if (buf == NULL || (buf->b_ml.ml_mfp == NULL && !empty_memline)
3163 || did_cmd || nofile_err
3164 #ifdef FEAT_EVAL
3165 || aborting()
3166 #endif
3169 --no_wait_return;
3170 msg_scroll = msg_save;
3171 if (nofile_err)
3172 EMSG(_("E676: No matching autocommands for acwrite buffer"));
3174 if (nofile_err
3175 #ifdef FEAT_EVAL
3176 || aborting()
3177 #endif
3179 /* An aborting error, interrupt or exception in the
3180 * autocommands. */
3181 return FAIL;
3182 if (did_cmd)
3184 if (buf == NULL)
3185 /* The buffer was deleted. We assume it was written
3186 * (can't retry anyway). */
3187 return OK;
3188 if (overwriting)
3190 /* Assume the buffer was written, update the timestamp. */
3191 ml_timestamp(buf);
3192 if (append)
3193 buf->b_flags &= ~BF_NEW;
3194 else
3195 buf->b_flags &= ~BF_WRITE_MASK;
3197 if (reset_changed && buf->b_changed && !append
3198 && (overwriting || vim_strchr(p_cpo, CPO_PLUS) != NULL))
3199 /* Buffer still changed, the autocommands didn't work
3200 * properly. */
3201 return FAIL;
3202 return OK;
3204 #ifdef FEAT_EVAL
3205 if (!aborting())
3206 #endif
3207 EMSG(_("E203: Autocommands deleted or unloaded buffer to be written"));
3208 return FAIL;
3212 * The autocommands may have changed the number of lines in the file.
3213 * When writing the whole file, adjust the end.
3214 * When writing part of the file, assume that the autocommands only
3215 * changed the number of lines that are to be written (tricky!).
3217 if (buf->b_ml.ml_line_count != old_line_count)
3219 if (whole) /* write all */
3220 end = buf->b_ml.ml_line_count;
3221 else if (buf->b_ml.ml_line_count > old_line_count) /* more lines */
3222 end += buf->b_ml.ml_line_count - old_line_count;
3223 else /* less lines */
3225 end -= old_line_count - buf->b_ml.ml_line_count;
3226 if (end < start)
3228 --no_wait_return;
3229 msg_scroll = msg_save;
3230 EMSG(_("E204: Autocommand changed number of lines in unexpected way"));
3231 return FAIL;
3237 * The autocommands may have changed the name of the buffer, which may
3238 * be kept in fname, ffname and sfname.
3240 if (buf_ffname)
3241 ffname = buf->b_ffname;
3242 if (buf_sfname)
3243 sfname = buf->b_sfname;
3244 if (buf_fname_f)
3245 fname = buf->b_ffname;
3246 if (buf_fname_s)
3247 fname = buf->b_sfname;
3249 #endif
3251 #ifdef FEAT_NETBEANS_INTG
3252 if (usingNetbeans && isNetbeansBuffer(buf))
3254 if (whole)
3257 * b_changed can be 0 after an undo, but we still need to write
3258 * the buffer to NetBeans.
3260 if (buf->b_changed || isNetbeansModified(buf))
3262 --no_wait_return; /* may wait for return now */
3263 msg_scroll = msg_save;
3264 netbeans_save_buffer(buf); /* no error checking... */
3265 return retval;
3267 else
3269 errnum = (char_u *)"E656: ";
3270 errmsg = (char_u *)_("NetBeans disallows writes of unmodified buffers");
3271 buffer = NULL;
3272 goto fail;
3275 else
3277 errnum = (char_u *)"E657: ";
3278 errmsg = (char_u *)_("Partial writes disallowed for NetBeans buffers");
3279 buffer = NULL;
3280 goto fail;
3283 #endif
3285 if (shortmess(SHM_OVER) && !exiting)
3286 msg_scroll = FALSE; /* overwrite previous file message */
3287 else
3288 msg_scroll = TRUE; /* don't overwrite previous file message */
3289 if (!filtering)
3290 filemess(buf,
3291 #ifndef UNIX
3292 sfname,
3293 #else
3294 fname,
3295 #endif
3296 (char_u *)"", 0); /* show that we are busy */
3297 msg_scroll = FALSE; /* always overwrite the file message now */
3299 buffer = alloc(BUFSIZE);
3300 if (buffer == NULL) /* can't allocate big buffer, use small
3301 * one (to be able to write when out of
3302 * memory) */
3304 buffer = smallbuf;
3305 bufsize = SMBUFSIZE;
3307 else
3308 bufsize = BUFSIZE;
3311 * Get information about original file (if there is one).
3313 #if defined(UNIX) && !defined(ARCHIE)
3314 st_old.st_dev = 0;
3315 st_old.st_ino = 0;
3316 perm = -1;
3317 if (mch_stat((char *)fname, &st_old) < 0)
3318 newfile = TRUE;
3319 else
3321 perm = st_old.st_mode;
3322 if (!S_ISREG(st_old.st_mode)) /* not a file */
3324 if (S_ISDIR(st_old.st_mode))
3326 errnum = (char_u *)"E502: ";
3327 errmsg = (char_u *)_("is a directory");
3328 goto fail;
3330 if (mch_nodetype(fname) != NODE_WRITABLE)
3332 errnum = (char_u *)"E503: ";
3333 errmsg = (char_u *)_("is not a file or writable device");
3334 goto fail;
3336 /* It's a device of some kind (or a fifo) which we can write to
3337 * but for which we can't make a backup. */
3338 device = TRUE;
3339 newfile = TRUE;
3340 perm = -1;
3343 #else /* !UNIX */
3345 * Check for a writable device name.
3347 c = mch_nodetype(fname);
3348 if (c == NODE_OTHER)
3350 errnum = (char_u *)"E503: ";
3351 errmsg = (char_u *)_("is not a file or writable device");
3352 goto fail;
3354 if (c == NODE_WRITABLE)
3356 # if defined(MSDOS) || defined(MSWIN) || defined(OS2)
3357 /* MS-Windows allows opening a device, but we will probably get stuck
3358 * trying to write to it. */
3359 if (!p_odev)
3361 errnum = (char_u *)"E796: ";
3362 errmsg = (char_u *)_("writing to device disabled with 'opendevice' option");
3363 goto fail;
3365 # endif
3366 device = TRUE;
3367 newfile = TRUE;
3368 perm = -1;
3370 else
3372 perm = mch_getperm(fname);
3373 if (perm < 0)
3374 newfile = TRUE;
3375 else if (mch_isdir(fname))
3377 errnum = (char_u *)"E502: ";
3378 errmsg = (char_u *)_("is a directory");
3379 goto fail;
3381 if (overwriting)
3382 (void)mch_stat((char *)fname, &st_old);
3384 #endif /* !UNIX */
3386 if (!device && !newfile)
3389 * Check if the file is really writable (when renaming the file to
3390 * make a backup we won't discover it later).
3392 file_readonly = check_file_readonly(fname, (int)perm);
3394 if (!forceit && file_readonly)
3396 if (vim_strchr(p_cpo, CPO_FWRITE) != NULL)
3398 errnum = (char_u *)"E504: ";
3399 errmsg = (char_u *)_(err_readonly);
3401 else
3403 errnum = (char_u *)"E505: ";
3404 errmsg = (char_u *)_("is read-only (add ! to override)");
3406 goto fail;
3410 * Check if the timestamp hasn't changed since reading the file.
3412 if (overwriting)
3414 retval = check_mtime(buf, &st_old);
3415 if (retval == FAIL)
3416 goto fail;
3420 #ifdef HAVE_ACL
3422 * For systems that support ACL: get the ACL from the original file.
3424 if (!newfile)
3425 acl = mch_get_acl(fname);
3426 #endif
3429 * If 'backupskip' is not empty, don't make a backup for some files.
3431 dobackup = (p_wb || p_bk || *p_pm != NUL);
3432 #ifdef FEAT_WILDIGN
3433 if (dobackup && *p_bsk != NUL && match_file_list(p_bsk, sfname, ffname))
3434 dobackup = FALSE;
3435 #endif
3438 * Save the value of got_int and reset it. We don't want a previous
3439 * interruption cancel writing, only hitting CTRL-C while writing should
3440 * abort it.
3442 prev_got_int = got_int;
3443 got_int = FALSE;
3445 /* Mark the buffer as 'being saved' to prevent changed buffer warnings */
3446 buf->b_saving = TRUE;
3449 * If we are not appending or filtering, the file exists, and the
3450 * 'writebackup', 'backup' or 'patchmode' option is set, need a backup.
3451 * When 'patchmode' is set also make a backup when appending.
3453 * Do not make any backup, if 'writebackup' and 'backup' are both switched
3454 * off. This helps when editing large files on almost-full disks.
3456 if (!(append && *p_pm == NUL) && !filtering && perm >= 0 && dobackup)
3458 #if defined(UNIX) || defined(WIN32)
3459 struct stat st;
3460 #endif
3462 if ((bkc_flags & BKC_YES) || append) /* "yes" */
3463 backup_copy = TRUE;
3464 #if defined(UNIX) || defined(WIN32)
3465 else if ((bkc_flags & BKC_AUTO)) /* "auto" */
3467 int i;
3469 # ifdef UNIX
3471 * Don't rename the file when:
3472 * - it's a hard link
3473 * - it's a symbolic link
3474 * - we don't have write permission in the directory
3475 * - we can't set the owner/group of the new file
3477 if (st_old.st_nlink > 1
3478 || mch_lstat((char *)fname, &st) < 0
3479 || st.st_dev != st_old.st_dev
3480 || st.st_ino != st_old.st_ino
3481 # ifndef HAVE_FCHOWN
3482 || st.st_uid != st_old.st_uid
3483 || st.st_gid != st_old.st_gid
3484 # endif
3486 backup_copy = TRUE;
3487 else
3488 # else
3489 # ifdef WIN32
3490 /* On NTFS file systems hard links are possible. */
3491 if (mch_is_linked(fname))
3492 backup_copy = TRUE;
3493 else
3494 # endif
3495 # endif
3498 * Check if we can create a file and set the owner/group to
3499 * the ones from the original file.
3500 * First find a file name that doesn't exist yet (use some
3501 * arbitrary numbers).
3503 STRCPY(IObuff, fname);
3504 for (i = 4913; ; i += 123)
3506 sprintf((char *)gettail(IObuff), "%d", i);
3507 if (mch_lstat((char *)IObuff, &st) < 0)
3508 break;
3510 fd = mch_open((char *)IObuff,
3511 O_CREAT|O_WRONLY|O_EXCL|O_NOFOLLOW, perm);
3512 if (fd < 0) /* can't write in directory */
3513 backup_copy = TRUE;
3514 else
3516 # ifdef UNIX
3517 # ifdef HAVE_FCHOWN
3518 ignored = fchown(fd, st_old.st_uid, st_old.st_gid);
3519 # endif
3520 if (mch_stat((char *)IObuff, &st) < 0
3521 || st.st_uid != st_old.st_uid
3522 || st.st_gid != st_old.st_gid
3523 || (long)st.st_mode != perm)
3524 backup_copy = TRUE;
3525 # endif
3526 /* Close the file before removing it, on MS-Windows we
3527 * can't delete an open file. */
3528 close(fd);
3529 mch_remove(IObuff);
3534 # ifdef UNIX
3536 * Break symlinks and/or hardlinks if we've been asked to.
3538 if ((bkc_flags & BKC_BREAKSYMLINK) || (bkc_flags & BKC_BREAKHARDLINK))
3540 int lstat_res;
3542 lstat_res = mch_lstat((char *)fname, &st);
3544 /* Symlinks. */
3545 if ((bkc_flags & BKC_BREAKSYMLINK)
3546 && lstat_res == 0
3547 && st.st_ino != st_old.st_ino)
3548 backup_copy = FALSE;
3550 /* Hardlinks. */
3551 if ((bkc_flags & BKC_BREAKHARDLINK)
3552 && st_old.st_nlink > 1
3553 && (lstat_res != 0 || st.st_ino == st_old.st_ino))
3554 backup_copy = FALSE;
3556 #endif
3558 #endif
3560 /* make sure we have a valid backup extension to use */
3561 if (*p_bex == NUL)
3563 #ifdef RISCOS
3564 backup_ext = (char_u *)"/bak";
3565 #else
3566 backup_ext = (char_u *)".bak";
3567 #endif
3569 else
3570 backup_ext = p_bex;
3572 if (backup_copy
3573 && (fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0)) >= 0)
3575 int bfd;
3576 char_u *copybuf, *wp;
3577 int some_error = FALSE;
3578 struct stat st_new;
3579 char_u *dirp;
3580 char_u *rootname;
3581 #if defined(UNIX) && !defined(SHORT_FNAME)
3582 int did_set_shortname;
3583 #endif
3585 copybuf = alloc(BUFSIZE + 1);
3586 if (copybuf == NULL)
3588 some_error = TRUE; /* out of memory */
3589 goto nobackup;
3593 * Try to make the backup in each directory in the 'bdir' option.
3595 * Unix semantics has it, that we may have a writable file,
3596 * that cannot be recreated with a simple open(..., O_CREAT, ) e.g:
3597 * - the directory is not writable,
3598 * - the file may be a symbolic link,
3599 * - the file may belong to another user/group, etc.
3601 * For these reasons, the existing writable file must be truncated
3602 * and reused. Creation of a backup COPY will be attempted.
3604 dirp = p_bdir;
3605 while (*dirp)
3607 #ifdef UNIX
3608 st_new.st_ino = 0;
3609 st_new.st_dev = 0;
3610 st_new.st_gid = 0;
3611 #endif
3614 * Isolate one directory name, using an entry in 'bdir'.
3616 (void)copy_option_part(&dirp, copybuf, BUFSIZE, ",");
3617 rootname = get_file_in_dir(fname, copybuf);
3618 if (rootname == NULL)
3620 some_error = TRUE; /* out of memory */
3621 goto nobackup;
3624 #if defined(UNIX) && !defined(SHORT_FNAME)
3625 did_set_shortname = FALSE;
3626 #endif
3629 * May try twice if 'shortname' not set.
3631 for (;;)
3634 * Make backup file name.
3636 backup = buf_modname(
3637 #ifdef SHORT_FNAME
3638 TRUE,
3639 #else
3640 (buf->b_p_sn || buf->b_shortname),
3641 #endif
3642 rootname, backup_ext, FALSE);
3643 if (backup == NULL)
3645 vim_free(rootname);
3646 some_error = TRUE; /* out of memory */
3647 goto nobackup;
3651 * Check if backup file already exists.
3653 if (mch_stat((char *)backup, &st_new) >= 0)
3655 #ifdef UNIX
3657 * Check if backup file is same as original file.
3658 * May happen when modname() gave the same file back.
3659 * E.g. silly link, or file name-length reached.
3660 * If we don't check here, we either ruin the file
3661 * when copying or erase it after writing. jw.
3663 if (st_new.st_dev == st_old.st_dev
3664 && st_new.st_ino == st_old.st_ino)
3666 vim_free(backup);
3667 backup = NULL; /* no backup file to delete */
3668 # ifndef SHORT_FNAME
3670 * may try again with 'shortname' set
3672 if (!(buf->b_shortname || buf->b_p_sn))
3674 buf->b_shortname = TRUE;
3675 did_set_shortname = TRUE;
3676 continue;
3678 /* setting shortname didn't help */
3679 if (did_set_shortname)
3680 buf->b_shortname = FALSE;
3681 # endif
3682 break;
3684 #endif
3687 * If we are not going to keep the backup file, don't
3688 * delete an existing one, try to use another name.
3689 * Change one character, just before the extension.
3691 if (!p_bk)
3693 wp = backup + STRLEN(backup) - 1
3694 - STRLEN(backup_ext);
3695 if (wp < backup) /* empty file name ??? */
3696 wp = backup;
3697 *wp = 'z';
3698 while (*wp > 'a'
3699 && mch_stat((char *)backup, &st_new) >= 0)
3700 --*wp;
3701 /* They all exist??? Must be something wrong. */
3702 if (*wp == 'a')
3704 vim_free(backup);
3705 backup = NULL;
3709 break;
3711 vim_free(rootname);
3714 * Try to create the backup file
3716 if (backup != NULL)
3718 /* remove old backup, if present */
3719 mch_remove(backup);
3720 /* Open with O_EXCL to avoid the file being created while
3721 * we were sleeping (symlink hacker attack?) */
3722 bfd = mch_open((char *)backup,
3723 O_WRONLY|O_CREAT|O_EXTRA|O_EXCL|O_NOFOLLOW,
3724 perm & 0777);
3725 if (bfd < 0)
3727 vim_free(backup);
3728 backup = NULL;
3730 else
3732 /* set file protection same as original file, but
3733 * strip s-bit */
3734 (void)mch_setperm(backup, perm & 0777);
3736 #ifdef UNIX
3738 * Try to set the group of the backup same as the
3739 * original file. If this fails, set the protection
3740 * bits for the group same as the protection bits for
3741 * others.
3743 if (st_new.st_gid != st_old.st_gid
3744 # ifdef HAVE_FCHOWN /* sequent-ptx lacks fchown() */
3745 && fchown(bfd, (uid_t)-1, st_old.st_gid) != 0
3746 # endif
3748 mch_setperm(backup,
3749 (perm & 0707) | ((perm & 07) << 3));
3750 # ifdef HAVE_SELINUX
3751 mch_copy_sec(fname, backup);
3752 # endif
3753 #endif
3756 * copy the file.
3758 write_info.bw_fd = bfd;
3759 write_info.bw_buf = copybuf;
3760 #ifdef HAS_BW_FLAGS
3761 write_info.bw_flags = FIO_NOCONVERT;
3762 #endif
3763 while ((write_info.bw_len = vim_read(fd, copybuf,
3764 BUFSIZE)) > 0)
3766 if (buf_write_bytes(&write_info) == FAIL)
3768 errmsg = (char_u *)_("E506: Can't write to backup file (add ! to override)");
3769 break;
3771 ui_breakcheck();
3772 if (got_int)
3774 errmsg = (char_u *)_(e_interr);
3775 break;
3779 if (close(bfd) < 0 && errmsg == NULL)
3780 errmsg = (char_u *)_("E507: Close error for backup file (add ! to override)");
3781 if (write_info.bw_len < 0)
3782 errmsg = (char_u *)_("E508: Can't read file for backup (add ! to override)");
3783 #ifdef UNIX
3784 set_file_time(backup, st_old.st_atime, st_old.st_mtime);
3785 #endif
3786 #ifdef HAVE_ACL
3787 mch_set_acl(backup, acl);
3788 #endif
3789 #ifdef HAVE_SELINUX
3790 mch_copy_sec(fname, backup);
3791 #endif
3792 break;
3796 nobackup:
3797 close(fd); /* ignore errors for closing read file */
3798 vim_free(copybuf);
3800 if (backup == NULL && errmsg == NULL)
3801 errmsg = (char_u *)_("E509: Cannot create backup file (add ! to override)");
3802 /* ignore errors when forceit is TRUE */
3803 if ((some_error || errmsg != NULL) && !forceit)
3805 retval = FAIL;
3806 goto fail;
3808 errmsg = NULL;
3810 else
3812 char_u *dirp;
3813 char_u *p;
3814 char_u *rootname;
3817 * Make a backup by renaming the original file.
3820 * If 'cpoptions' includes the "W" flag, we don't want to
3821 * overwrite a read-only file. But rename may be possible
3822 * anyway, thus we need an extra check here.
3824 if (file_readonly && vim_strchr(p_cpo, CPO_FWRITE) != NULL)
3826 errnum = (char_u *)"E504: ";
3827 errmsg = (char_u *)_(err_readonly);
3828 goto fail;
3833 * Form the backup file name - change path/fo.o.h to
3834 * path/fo.o.h.bak Try all directories in 'backupdir', first one
3835 * that works is used.
3837 dirp = p_bdir;
3838 while (*dirp)
3841 * Isolate one directory name and make the backup file name.
3843 (void)copy_option_part(&dirp, IObuff, IOSIZE, ",");
3844 rootname = get_file_in_dir(fname, IObuff);
3845 if (rootname == NULL)
3846 backup = NULL;
3847 else
3849 backup = buf_modname(
3850 #ifdef SHORT_FNAME
3851 TRUE,
3852 #else
3853 (buf->b_p_sn || buf->b_shortname),
3854 #endif
3855 rootname, backup_ext, FALSE);
3856 vim_free(rootname);
3859 if (backup != NULL)
3862 * If we are not going to keep the backup file, don't
3863 * delete an existing one, try to use another name.
3864 * Change one character, just before the extension.
3866 if (!p_bk && mch_getperm(backup) >= 0)
3868 p = backup + STRLEN(backup) - 1 - STRLEN(backup_ext);
3869 if (p < backup) /* empty file name ??? */
3870 p = backup;
3871 *p = 'z';
3872 while (*p > 'a' && mch_getperm(backup) >= 0)
3873 --*p;
3874 /* They all exist??? Must be something wrong! */
3875 if (*p == 'a')
3877 vim_free(backup);
3878 backup = NULL;
3882 if (backup != NULL)
3885 * Delete any existing backup and move the current version
3886 * to the backup. For safety, we don't remove the backup
3887 * until the write has finished successfully. And if the
3888 * 'backup' option is set, leave it around.
3891 * If the renaming of the original file to the backup file
3892 * works, quit here.
3894 if (vim_rename(fname, backup) == 0)
3895 break;
3897 vim_free(backup); /* don't do the rename below */
3898 backup = NULL;
3901 if (backup == NULL && !forceit)
3903 errmsg = (char_u *)_("E510: Can't make backup file (add ! to override)");
3904 goto fail;
3909 #if defined(UNIX) && !defined(ARCHIE)
3910 /* When using ":w!" and the file was read-only: make it writable */
3911 if (forceit && perm >= 0 && !(perm & 0200) && st_old.st_uid == getuid()
3912 && vim_strchr(p_cpo, CPO_FWRITE) == NULL)
3914 perm |= 0200;
3915 (void)mch_setperm(fname, perm);
3916 made_writable = TRUE;
3918 #endif
3920 /* When using ":w!" and writing to the current file, 'readonly' makes no
3921 * sense, reset it, unless 'Z' appears in 'cpoptions'. */
3922 if (forceit && overwriting && vim_strchr(p_cpo, CPO_KEEPRO) == NULL)
3924 buf->b_p_ro = FALSE;
3925 #ifdef FEAT_TITLE
3926 need_maketitle = TRUE; /* set window title later */
3927 #endif
3928 #ifdef FEAT_WINDOWS
3929 status_redraw_all(); /* redraw status lines later */
3930 #endif
3933 if (end > buf->b_ml.ml_line_count)
3934 end = buf->b_ml.ml_line_count;
3935 if (buf->b_ml.ml_flags & ML_EMPTY)
3936 start = end + 1;
3939 * If the original file is being overwritten, there is a small chance that
3940 * we crash in the middle of writing. Therefore the file is preserved now.
3941 * This makes all block numbers positive so that recovery does not need
3942 * the original file.
3943 * Don't do this if there is a backup file and we are exiting.
3945 if (reset_changed && !newfile && overwriting
3946 && !(exiting && backup != NULL))
3948 ml_preserve(buf, FALSE);
3949 if (got_int)
3951 errmsg = (char_u *)_(e_interr);
3952 goto restore_backup;
3956 #ifdef MACOS_CLASSIC /* TODO: Is it need for MACOS_X? (Dany) */
3958 * Before risking to lose the original file verify if there's
3959 * a resource fork to preserve, and if cannot be done warn
3960 * the users. This happens when overwriting without backups.
3962 if (backup == NULL && overwriting && !append)
3963 if (mch_has_resource_fork(fname))
3965 errmsg = (char_u *)_("E460: The resource fork would be lost (add ! to override)");
3966 goto restore_backup;
3968 #endif
3970 #ifdef VMS
3971 vms_remove_version(fname); /* remove version */
3972 #endif
3973 /* Default: write the file directly. May write to a temp file for
3974 * multi-byte conversion. */
3975 wfname = fname;
3977 #ifdef FEAT_MBYTE
3978 /* Check for forced 'fileencoding' from "++opt=val" argument. */
3979 if (eap != NULL && eap->force_enc != 0)
3981 fenc = eap->cmd + eap->force_enc;
3982 fenc = enc_canonize(fenc);
3983 fenc_tofree = fenc;
3985 else
3986 fenc = buf->b_p_fenc;
3989 * Check if the file needs to be converted.
3991 converted = need_conversion(fenc);
3994 * Check if UTF-8 to UCS-2/4 or Latin1 conversion needs to be done. Or
3995 * Latin1 to Unicode conversion. This is handled in buf_write_bytes().
3996 * Prepare the flags for it and allocate bw_conv_buf when needed.
3998 if (converted && (enc_utf8 || STRCMP(p_enc, "latin1") == 0))
4000 wb_flags = get_fio_flags(fenc);
4001 if (wb_flags & (FIO_UCS2 | FIO_UCS4 | FIO_UTF16 | FIO_UTF8))
4003 /* Need to allocate a buffer to translate into. */
4004 if (wb_flags & (FIO_UCS2 | FIO_UTF16 | FIO_UTF8))
4005 write_info.bw_conv_buflen = bufsize * 2;
4006 else /* FIO_UCS4 */
4007 write_info.bw_conv_buflen = bufsize * 4;
4008 write_info.bw_conv_buf
4009 = lalloc((long_u)write_info.bw_conv_buflen, TRUE);
4010 if (write_info.bw_conv_buf == NULL)
4011 end = 0;
4015 # ifdef WIN3264
4016 if (converted && wb_flags == 0 && (wb_flags = get_win_fio_flags(fenc)) != 0)
4018 /* Convert UTF-8 -> UCS-2 and UCS-2 -> DBCS. Worst-case * 4: */
4019 write_info.bw_conv_buflen = bufsize * 4;
4020 write_info.bw_conv_buf
4021 = lalloc((long_u)write_info.bw_conv_buflen, TRUE);
4022 if (write_info.bw_conv_buf == NULL)
4023 end = 0;
4025 # endif
4027 # ifdef MACOS_X
4028 if (converted && wb_flags == 0 && (wb_flags = get_mac_fio_flags(fenc)) != 0)
4030 write_info.bw_conv_buflen = bufsize * 3;
4031 write_info.bw_conv_buf
4032 = lalloc((long_u)write_info.bw_conv_buflen, TRUE);
4033 if (write_info.bw_conv_buf == NULL)
4034 end = 0;
4036 # endif
4038 # if defined(FEAT_EVAL) || defined(USE_ICONV)
4039 if (converted && wb_flags == 0)
4041 # ifdef USE_ICONV
4043 * Use iconv() conversion when conversion is needed and it's not done
4044 * internally.
4046 write_info.bw_iconv_fd = (iconv_t)my_iconv_open(fenc,
4047 enc_utf8 ? (char_u *)"utf-8" : p_enc);
4048 if (write_info.bw_iconv_fd != (iconv_t)-1)
4050 /* We're going to use iconv(), allocate a buffer to convert in. */
4051 write_info.bw_conv_buflen = bufsize * ICONV_MULT;
4052 write_info.bw_conv_buf
4053 = lalloc((long_u)write_info.bw_conv_buflen, TRUE);
4054 if (write_info.bw_conv_buf == NULL)
4055 end = 0;
4056 write_info.bw_first = TRUE;
4058 # ifdef FEAT_EVAL
4059 else
4060 # endif
4061 # endif
4063 # ifdef FEAT_EVAL
4065 * When the file needs to be converted with 'charconvert' after
4066 * writing, write to a temp file instead and let the conversion
4067 * overwrite the original file.
4069 if (*p_ccv != NUL)
4071 wfname = vim_tempname('w');
4072 if (wfname == NULL) /* Can't write without a tempfile! */
4074 errmsg = (char_u *)_("E214: Can't find temp file for writing");
4075 goto restore_backup;
4078 # endif
4080 # endif
4081 if (converted && wb_flags == 0
4082 # ifdef USE_ICONV
4083 && write_info.bw_iconv_fd == (iconv_t)-1
4084 # endif
4085 # ifdef FEAT_EVAL
4086 && wfname == fname
4087 # endif
4090 if (!forceit)
4092 errmsg = (char_u *)_("E213: Cannot convert (add ! to write without conversion)");
4093 goto restore_backup;
4095 notconverted = TRUE;
4097 #endif
4100 * Open the file "wfname" for writing.
4101 * We may try to open the file twice: If we can't write to the
4102 * file and forceit is TRUE we delete the existing file and try to create
4103 * a new one. If this still fails we may have lost the original file!
4104 * (this may happen when the user reached his quotum for number of files).
4105 * Appending will fail if the file does not exist and forceit is FALSE.
4107 while ((fd = mch_open((char *)wfname, O_WRONLY | O_EXTRA | (append
4108 ? (forceit ? (O_APPEND | O_CREAT) : O_APPEND)
4109 : (O_CREAT | O_TRUNC))
4110 , perm < 0 ? 0666 : (perm & 0777))) < 0)
4113 * A forced write will try to create a new file if the old one is
4114 * still readonly. This may also happen when the directory is
4115 * read-only. In that case the mch_remove() will fail.
4117 if (errmsg == NULL)
4119 #ifdef UNIX
4120 struct stat st;
4122 /* Don't delete the file when it's a hard or symbolic link. */
4123 if ((!newfile && st_old.st_nlink > 1)
4124 || (mch_lstat((char *)fname, &st) == 0
4125 && (st.st_dev != st_old.st_dev
4126 || st.st_ino != st_old.st_ino)))
4127 errmsg = (char_u *)_("E166: Can't open linked file for writing");
4128 else
4129 #endif
4131 errmsg = (char_u *)_("E212: Can't open file for writing");
4132 if (forceit && vim_strchr(p_cpo, CPO_FWRITE) == NULL
4133 && perm >= 0)
4135 #ifdef UNIX
4136 /* we write to the file, thus it should be marked
4137 writable after all */
4138 if (!(perm & 0200))
4139 made_writable = TRUE;
4140 perm |= 0200;
4141 if (st_old.st_uid != getuid() || st_old.st_gid != getgid())
4142 perm &= 0777;
4143 #endif
4144 if (!append) /* don't remove when appending */
4145 mch_remove(wfname);
4146 continue;
4151 restore_backup:
4153 struct stat st;
4156 * If we failed to open the file, we don't need a backup. Throw it
4157 * away. If we moved or removed the original file try to put the
4158 * backup in its place.
4160 if (backup != NULL && wfname == fname)
4162 if (backup_copy)
4165 * There is a small chance that we removed the original,
4166 * try to move the copy in its place.
4167 * This may not work if the vim_rename() fails.
4168 * In that case we leave the copy around.
4170 /* If file does not exist, put the copy in its place */
4171 if (mch_stat((char *)fname, &st) < 0)
4172 vim_rename(backup, fname);
4173 /* if original file does exist throw away the copy */
4174 if (mch_stat((char *)fname, &st) >= 0)
4175 mch_remove(backup);
4177 else
4179 /* try to put the original file back */
4180 vim_rename(backup, fname);
4184 /* if original file no longer exists give an extra warning */
4185 if (!newfile && mch_stat((char *)fname, &st) < 0)
4186 end = 0;
4189 #ifdef FEAT_MBYTE
4190 if (wfname != fname)
4191 vim_free(wfname);
4192 #endif
4193 goto fail;
4195 errmsg = NULL;
4197 #if defined(MACOS_CLASSIC) || defined(WIN3264)
4198 /* TODO: Is it need for MACOS_X? (Dany) */
4200 * On macintosh copy the original files attributes (i.e. the backup)
4201 * This is done in order to preserve the resource fork and the
4202 * Finder attribute (label, comments, custom icons, file creator)
4204 if (backup != NULL && overwriting && !append)
4206 if (backup_copy)
4207 (void)mch_copy_file_attribute(wfname, backup);
4208 else
4209 (void)mch_copy_file_attribute(backup, wfname);
4212 if (!overwriting && !append)
4214 if (buf->b_ffname != NULL)
4215 (void)mch_copy_file_attribute(buf->b_ffname, wfname);
4216 /* Should copy resource fork */
4218 #endif
4220 write_info.bw_fd = fd;
4222 #ifdef FEAT_CRYPT
4223 if (*buf->b_p_key && !filtering)
4225 crypt_init_keys(buf->b_p_key);
4226 /* Write magic number, so that Vim knows that this file is encrypted
4227 * when reading it again. This also undergoes utf-8 to ucs-2/4
4228 * conversion when needed. */
4229 write_info.bw_buf =