?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote branch 'svn-vim' into vim
[MacVim.git] / src / fileio.c
blob88188e5979417eea465f8798cf3c16b2fd4a7a23
1 /* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
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 */
9
10 /*
11 * fileio.c: read from and write to a file
12 */
13
14 #if defined(MSDOS) || defined(WIN16) || defined(WIN32) || defined(_WIN64)
15 # include "vimio.h" /* for lseek(), must be before vim.h */
16 #endif
17
18 #if defined __EMX__
19 # include "vimio.h" /* for mktemp(), CJW 1997-12-03 */
20 #endif
21
22 #include "vim.h"
23
24 #if defined(__TANDEM) || defined(__MINT__)
25 # include <limits.h> /* for SSIZE_MAX */
26 #endif
27
28 #if defined(HAVE_UTIME) && defined(HAVE_UTIME_H)
29 # include <utime.h> /* for struct utimbuf */
30 #endif
31
32 #define BUFSIZE 8192 /* size of normal write buffer */
33 #define SMBUFSIZE 256 /* size of emergency write buffer */
34
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
39
40 /* Is there any system that doesn't have access()? */
41 #define USE_MCH_ACCESS
42
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));
70
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
75
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
97
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
101
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
105
106 /*
107 * Structure to pass arguments from buf_write() to buf_write_bytes().
108 */
109 struct bw_info
110 {
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
130 };
131
132 static int buf_write_bytes __ARGS((struct bw_info *ip));
133
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
155
156 void
157 filemess(buf, name, s, attr)
158 buf_T *buf;
159 char_u *name;
160 char_u *s;
161 int attr;
162 {
163 int msg_scroll_save;
164
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);
172 /*
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().
176 */
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;
190 }
191
192 /*
193 * Read lines from file "fname" into the buffer after line "from".
194 *
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().
198 *
199 * (caller must check that fname != NULL, unless READ_STDIN is used)
200 *
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.
204 *
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)
212 *
213 * return FAIL for failure, OK otherwise
214 */
215 int
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;
224 {
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
304
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 */
319
320 /*
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.
325 */
326 if (curbuf->b_ffname == NULL
327 && !filtering
328 && fname != NULL
329 && vim_strchr(p_cpo, CPO_FNAMER) != NULL
330 && !(flags & READ_DUMMY))
331 {
332 if (set_rw_fname(fname, sfname) == FAIL)
333 return FAIL;
334 }
335
336 /* After reading a file the cursor line changes but we don't want to
337 * display the line. */
338 ex_no_reprint = TRUE;
339
340 /* don't display the file info for another buffer now */
341 need_fileinfo = FALSE;
342
343 /*
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.
348 */
349 if (sfname == NULL)
350 sfname = fname;
351 #if defined(UNIX) || defined(__EMX__)
352 fname = sfname;
353 #endif
354
355 #ifdef FEAT_AUTOCMD
356 /*
357 * The BufReadCmd and FileReadCmd events intercept the reading process by
358 * executing the associated commands instead.
359 */
360 if (!filtering && !read_stdin && !read_buffer)
361 {
362 pos_T pos;
363
364 pos = curbuf->b_op_start;
365
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;
369
370 if (newfile)
371 {
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
379 }
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
387
388 curbuf->b_op_start = pos;
389 }
390 #endif
391
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 */
396
397 /*
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.
402 */
403 if (fname != NULL && *fname != NUL)
404 {
405 p = fname + STRLEN(fname);
406 if (after_pathsep(fname, p) || STRLEN(fname) >= MAXPATHL)
407 {
408 filemess(curbuf, fname, (char_u *)_("Illegal file name"), 0);
409 msg_end();
410 msg_scroll = msg_save;
411 return FAIL;
412 }
413 }
414
415 #ifdef UNIX
416 /*
417 * On Unix it is possible to read a directory, so we have to
418 * check for it before the mch_open().
419 */
420 if (!read_stdin && !read_buffer)
421 {
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
434 )
435 {
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;
443 }
444
445 # if defined(MSDOS) || defined(MSWIN) || defined(OS2)
446 /*
447 * MS-Windows allows opening a device, but we will probably get stuck
448 * trying to read it.
449 */
450 if (!p_odev && mch_nodetype(fname) == NODE_WRITABLE)
451 {
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;
456 }
457 # endif
458 }
459 #endif
460
461 /* set default 'fileformat' */
462 if (set_options)
463 {
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);
468 }
469
470 /* set or reset 'binary' */
471 if (eap != NULL && eap->force_bin != 0)
472 {
473 int oldval = curbuf->b_p_bin;
474
475 curbuf->b_p_bin = (eap->force_bin == FORCE_BIN);
476 set_options_bin(oldval, curbuf->b_p_bin, OPT_LOCAL);
477 }
478
479 /*
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.
484 */
485 check_readonly = (newfile && (curbuf->b_flags & BF_CHECK_RO));
486 if (check_readonly && !readonlymode)
487 curbuf->b_p_ro = FALSE;
488
489 if (newfile && !read_stdin && !read_buffer)
490 {
491 /* Remember time of file.
492 * For RISCOS, also remember the filetype.
493 */
494 if (mch_stat((char *)fname, &st) >= 0)
495 {
496 buf_store_time(curbuf, &st, fname);
497 curbuf->b_mtime_read = curbuf->b_mtime;
498
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
504 /*
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.
514 */
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
520 */
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
528 }
529 else
530 {
531 curbuf->b_mtime = 0;
532 curbuf->b_mtime_read = 0;
533 curbuf->b_orig_size = 0;
534 curbuf->b_orig_mode = 0;
535 }
536
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);
540 }
541
542 /*
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
546 */
547 file_readonly = FALSE;
548 if (read_stdin)
549 {
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
554 }
555 else if (!read_buffer)
556 {
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)
569 {
570 file_readonly = TRUE;
571 /* try to open ro */
572 fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
573 }
574 #endif
575 }
576
577 if (fd < 0) /* cannot open at all */
578 {
579 #ifndef UNIX
580 int isdir_f;
581 #endif
582 msg_scroll = msg_save;
583 #ifndef UNIX
584 /*
585 * On MSDOS and Amiga we can't open a directory, check here.
586 */
587 isdir_f = (mch_isdir(fname));
588 perm = mch_getperm(fname); /* check if the file exists */
589 if (isdir_f)
590 {
591 filemess(curbuf, sfname, (char_u *)_("is a directory"), 0);
592 curbuf->b_p_ro = TRUE; /* must use "w!" now */
593 }
594 else
595 #endif
596 if (newfile)
597 {
598 if (perm < 0)
599 {
600 /*
601 * Set the 'new-file' flag, so that when the file has
602 * been created by someone else, a ":w" will complain.
603 */
604 curbuf->b_flags |= BF_NEW;
605
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
612 {
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)))
621 {
622 EMSG(_(e_auchangedbuf));
623 return FAIL;
624 }
625 #endif
626 }
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)
639 {
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);
646 }
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);
654
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 */
660 }
661 else
662 {
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 */
669 }
670 }
671
672 return FAIL;
673 }
674
675 /*
676 * Only set the 'ro' flag for readonly files the first time they are
677 * loaded. Help files always get readonly mode
678 */
679 if ((check_readonly && file_readonly) || curbuf->b_help)
680 curbuf->b_p_ro = TRUE;
681
682 if (set_options)
683 {
684 /* Don't change 'eol' if reading from buffer as it will already be
685 * correctly set when reading stdin. */
686 if (!read_buffer)
687 {
688 curbuf->b_p_eol = TRUE;
689 curbuf->b_start_eol = TRUE;
690 }
691 #ifdef FEAT_MBYTE
692 curbuf->b_p_bomb = FALSE;
693 curbuf->b_start_bomb = FALSE;
694 #endif
695 }
696
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
703 {
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))))
709 {
710 EMSG(_(e_auchangedbuf));
711 if (!read_buffer)
712 close(fd);
713 return FAIL;
714 }
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
722 }
723
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)
727 {
728 if (!read_buffer && !read_stdin)
729 close(fd);
730 return FAIL;
731 }
732 #endif
733
734 ++no_wait_return; /* don't wait for return yet */
735
736 /*
737 * Set '[ mark to the line above where the lines go (line 1 if zero).
738 */
739 curbuf->b_op_start.lnum = ((from == 0) ? 1 : from);
740 curbuf->b_op_start.col = 0;
741
742 #ifdef FEAT_AUTOCMD
743 if (!read_buffer)
744 {
745 int m = msg_scroll;
746 int n = msg_scrolled;
747
748 /*
749 * The file must be closed again, the autocommands may want to change
750 * the file before reading it.
751 */
752 if (!read_stdin)
753 close(fd); /* ignore errors */
754
755 /*
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.
759 */
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;
775
776 #ifdef FEAT_EVAL
777 if (aborting()) /* autocmds may abort script processing */
778 {
779 --no_wait_return;
780 msg_scroll = msg_save;
781 curbuf->b_p_ro = TRUE; /* must use "w!" now */
782 return FAIL;
783 }
784 #endif
785 /*
786 * Don't allow the autocommands to change the current buffer.
787 * Try to re-open the file.
788 *
789 * Don't allow the autocommands to change the buffer name either
790 * (cd for example) if it invalidates fname or sfname.
791 */
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))
796 {
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;
805 }
806 }
807 #endif /* FEAT_AUTOCMD */
808
809 /* Autocommands may add lines to the file, need to check if it is empty */
810 wasempty = (curbuf->b_ml.ml_flags & ML_EMPTY);
811
812 if (!recoverymode && !filtering && !(flags & READ_DUMMY))
813 {
814 /*
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.
819 */
820 if (read_stdin)
821 {
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)
828 {
829 p = (char_u *)_("Reading from stdin...");
830 gui_write(p, (int)STRLEN(p));
831 }
832 #endif
833 }
834 else if (!read_buffer)
835 filemess(curbuf, sfname, (char_u *)"", 0);
836 }
837
838 msg_scroll = FALSE; /* overwrite the file message */
839
840 /*
841 * Set linecnt now, before the "retry" caused by a wrong guess for
842 * fileformat, and after the autocommands, which may change them.
843 */
844 linecnt = curbuf->b_ml.ml_line_count;
845
846 #ifdef FEAT_MBYTE
847 /* "++bad=" argument. */
848 if (eap != NULL && eap->bad_char != 0)
849 {
850 bad_char_behavior = eap->bad_char;
851 if (set_options)
852 curbuf->b_bad_char = eap->bad_char;
853 }
854 else
855 curbuf->b_bad_char = 0;
856
857 /*
858 * Decide which 'encoding' to use or use first.
859 */
860 if (eap != NULL && eap->force_enc != 0)
861 {
862 fenc = enc_canonize(eap->cmd + eap->force_enc);
863 fenc_alloced = TRUE;
864 keep_dest_enc = TRUE;
865 }
866 else if (curbuf->b_p_bin)
867 {
868 fenc = (char_u *)""; /* binary: don't convert */
869 fenc_alloced = FALSE;
870 }
871 else if (curbuf->b_help)
872 {
873 char_u firstline[80];
874 int fc;
875
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)
885 {
886 fc = fname[STRLEN(fname) - 1];
887 if (TOLOWER_ASC(fc) == 'x')
888 {
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)
895 {
896 c = TRUE;
897 break;
898 }
899 }
900 }
901
902 if (c)
903 {
904 fenc_next = fenc;
905 fenc = (char_u *)"utf-8";
906
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;
912 }
913 fenc_alloced = FALSE;
914 }
915 else if (*p_fencs == NUL)
916 {
917 fenc = curbuf->b_p_fenc; /* use format from buffer */
918 fenc_alloced = FALSE;
919 }
920 else
921 {
922 fenc_next = p_fencs; /* try items in 'fileencodings' */
923 fenc = next_fenc(&fenc_next);
924 fenc_alloced = TRUE;
925 }
926 #endif
927
928 /*
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
934 *
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".
941 *
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().
946 */
947 retry:
948
949 if (file_rewind)
950 {
951 if (read_buffer)
952 {
953 read_buf_lnum = 1;
954 read_buf_col = 0;
955 }
956 else if (read_stdin || lseek(fd, (off_t)0L, SEEK_SET) != 0)
957 {
958 /* Can't rewind the file, give up. */
959 error = TRUE;
960 goto failed;
961 }
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)
968 {
969 curbuf->b_p_bomb = FALSE;
970 curbuf->b_start_bomb = FALSE;
971 }
972 conv_error = 0;
973 #endif
974 }
975
976 /*
977 * When retrying with another "fenc" and the first time "fileformat"
978 * will be reset.
979 */
980 if (keep_fileformat)
981 keep_fileformat = FALSE;
982 else
983 {
984 if (eap != NULL && eap->force_ff != 0)
985 {
986 fileformat = get_fileformat_force(curbuf, eap);
987 try_unix = try_dos = try_mac = FALSE;
988 }
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 */
995 }
996
997 #ifdef FEAT_MBYTE
998 # ifdef USE_ICONV
999 if (iconv_fd != (iconv_t)-1)
1000 {
1001 /* aborted conversion with iconv(), close the descriptor */
1002 iconv_close(iconv_fd);
1003 iconv_fd = (iconv_t)-1;
1004 }
1005 # endif
1006
1007 if (advance_fenc)
1008 {
1009 /*
1010 * Try the next entry in 'fileencodings'.
1011 */
1012 advance_fenc = FALSE;
1013
1014 if (eap != NULL && eap->force_enc != 0)
1015 {
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;
1024 }
1025 else
1026 {
1027 if (fenc_alloced)
1028 vim_free(fenc);
1029 if (fenc_next != NULL)
1030 {
1031 fenc = next_fenc(&fenc_next);
1032 fenc_alloced = (fenc_next != NULL);
1033 }
1034 else
1035 {
1036 fenc = (char_u *)"";
1037 fenc_alloced = FALSE;
1038 }
1039 }
1040 if (tmpname != NULL)
1041 {
1042 mch_remove(tmpname); /* delete converted file */
1043 vim_free(tmpname);
1044 tmpname = NULL;
1045 }
1046 }
1047
1048 /*
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.
1051 */
1052 fio_flags = 0;
1053 converted = need_conversion(fenc);
1054 if (converted)
1055 {
1056
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;
1061
1062 /*
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.
1070 */
1071 else if (enc_utf8 || STRCMP(p_enc, "latin1") == 0)
1072 fio_flags = get_fio_flags(fenc);
1073
1074 # ifdef WIN3264
1075 /*
1076 * Conversion from an MS-Windows codepage to UTF-8 or another codepage
1077 * is handled with MultiByteToWideChar().
1078 */
1079 if (fio_flags == 0)
1080 fio_flags = get_win_fio_flags(fenc);
1081 # endif
1082
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
1088
1089 # ifdef USE_ICONV
1090 /*
1091 * Try using iconv() if we can't convert internally.
1092 */
1093 if (fio_flags == 0
1094 # ifdef FEAT_EVAL
1095 && !did_iconv
1096 # endif
1097 )
1098 iconv_fd = (iconv_t)my_iconv_open(
1099 enc_utf8 ? (char_u *)"utf-8" : p_enc, fenc);
1100 # endif
1101
1102 # ifdef FEAT_EVAL
1103 /*
1104 * Use the 'charconvert' expression when conversion is required
1105 * and we can't do it internally or with iconv().
1106 */
1107 if (fio_flags == 0 && !read_stdin && !read_buffer && *p_ccv != NUL
1108 # ifdef USE_ICONV
1109 && iconv_fd == (iconv_t)-1
1110 # endif
1111 )
1112 {
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)
1119 {
1120 tmpname = readfile_charconvert(fname, fenc, &fd);
1121 if (tmpname == NULL)
1122 {
1123 /* Conversion failed. Try another one. */
1124 advance_fenc = TRUE;
1125 if (fd < 0)
1126 {
1127 /* Re-opening the original file failed! */
1128 EMSG(_("E202: Conversion made file unreadable!"));
1129 error = TRUE;
1130 goto failed;
1131 }
1132 goto retry;
1133 }
1134 }
1135 }
1136 else
1137 # endif
1138 {
1139 if (fio_flags == 0
1140 # ifdef USE_ICONV
1141 && iconv_fd == (iconv_t)-1
1142 # endif
1143 )
1144 {
1145 /* Conversion wanted but we can't.
1146 * Try the next conversion in 'fileencodings' */
1147 advance_fenc = TRUE;
1148 goto retry;
1149 }
1150 }
1151 }
1152
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
1158
1159 if (!skip_read)
1160 {
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
1168 }
1169
1170 while (!error && !got_int)
1171 {
1172 /*
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).
1177 */
1178 #if SIZEOF_INT <= 2
1179 if (linerest >= 0x7ff0)
1180 {
1181 ++split;
1182 *ptr = NL; /* split line by inserting a NL */
1183 size = 1;
1184 }
1185 else
1186 #endif
1187 {
1188 if (!skip_read)
1189 {
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
1199
1200 for ( ; size >= 10; size = (long)((long_u)size >> 1))
1201 {
1202 if ((new_buffer = lalloc((long_u)(size + linerest + 1),
1203 FALSE)) != NULL)
1204 break;
1205 }
1206 if (new_buffer == NULL)
1207 {
1208 do_outofmem_msg((long_u)(size * 2 + linerest + 1));
1209 error = TRUE;
1210 break;
1211 }
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;
1218
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
1253
1254 #ifdef FEAT_MBYTE
1255 if (conv_restlen > 0)
1256 {
1257 /* Insert unconverted bytes from previous line. */
1258 mch_memmove(ptr, conv_rest, conv_restlen);
1259 ptr += conv_restlen;
1260 size -= conv_restlen;
1261 }
1262 #endif
1263
1264 if (read_buffer)
1265 {
1266 /*
1267 * Read bytes from curbuf. Used for converting text read
1268 * from stdin.
1269 */
1270 if (read_buf_lnum > from)
1271 size = 0;
1272 else
1273 {
1274 int n, ni;
1275 long tlen;
1276
1277 tlen = 0;
1278 for (;;)
1279 {
1280 p = ml_get(read_buf_lnum) + read_buf_col;
1281 n = (int)STRLEN(p);
1282 if ((int)tlen + n + 1 > size)
1283 {
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)
1289 {
1290 if (p[ni] == NL)
1291 ptr[tlen++] = NUL;
1292 else
1293 ptr[tlen++] = p[ni];
1294 }
1295 read_buf_col += n;
1296 break;
1297 }
1298 else
1299 {
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)
1303 {
1304 if (p[ni] == NL)
1305 ptr[tlen++] = NUL;
1306 else
1307 ptr[tlen++] = p[ni];
1308 }
1309 ptr[tlen++] = NL;
1310 read_buf_col = 0;
1311 if (++read_buf_lnum > from)
1312 {
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;
1319 }
1320 }
1321 }
1322 }
1323 }
1324 else
1325 {
1326 /*
1327 * Read bytes from the file.
1328 */
1329 size = vim_read(fd, ptr, size);
1330 }
1331
1332 if (size <= 0)
1333 {
1334 if (size < 0) /* read error */
1335 error = TRUE;
1336 #ifdef FEAT_MBYTE
1337 else if (conv_restlen > 0)
1338 {
1339 /*
1340 * Reached end-of-file but some trailing bytes could
1341 * not be converted. Truncated file?
1342 */
1343
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
1349 )
1350 {
1351 if (conv_error == 0)
1352 conv_error = curbuf->b_ml.ml_line_count
1353 - linecnt + 1;
1354 }
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)
1360 {
1361 *(ptr - conv_restlen) = NUL;
1362 conv_restlen = 0;
1363 }
1364 else
1365 {
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
1374 ))
1375 {
1376 while (conv_restlen > 0)
1377 {
1378 *(--ptr) = bad_char_behavior;
1379 --conv_restlen;
1380 }
1381 }
1382 fio_flags = 0; /* don't convert this */
1383 # ifdef USE_ICONV
1384 if (iconv_fd != (iconv_t)-1)
1385 {
1386 iconv_close(iconv_fd);
1387 iconv_fd = (iconv_t)-1;
1388 }
1389 # endif
1390 }
1391 }
1392 #endif
1393 }
1394
1395 #ifdef FEAT_CRYPT
1396 /*
1397 * At start of file: Check for magic number of encryption.
1398 */
1399 if (filesize == 0)
1400 cryptkey = check_for_cryptkey(cryptkey, ptr, &size,
1401 &filesize, newfile);
1402 /*
1403 * Decrypt the read bytes.
1404 */
1405 if (cryptkey != NULL && size > 0)
1406 for (p = ptr; p < ptr + size; ++p)
1407 ZDECODE(*p);
1408 #endif
1409 }
1410 skip_read = FALSE;
1411
1412 #ifdef FEAT_MBYTE
1413 /*
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.
1418 */
1419 if ((filesize == 0
1420 # ifdef FEAT_CRYPT
1421 || (filesize == CRYPT_MAGIC_LEN && cryptkey != NULL)
1422 # endif
1423 )
1424 && (fio_flags == FIO_UCSBOM
1425 || (!curbuf->b_p_bomb
1426 && tmpname == NULL
1427 && (*fenc == 'u' || (*fenc == NUL && enc_utf8)))))
1428 {
1429 char_u *ccname;
1430 int blen;
1431
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)
1439 {
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)
1445 {
1446 curbuf->b_p_bomb = TRUE;
1447 curbuf->b_start_bomb = TRUE;
1448 }
1449 }
1450
1451 if (fio_flags == FIO_UCSBOM)
1452 {
1453 if (ccname == NULL)
1454 {
1455 /* No BOM detected: retry with next encoding. */
1456 advance_fenc = TRUE;
1457 }
1458 else
1459 {
1460 /* BOM detected: set "fenc" and jump back */
1461 if (fenc_alloced)
1462 vim_free(fenc);
1463 fenc = ccname;
1464 fenc_alloced = FALSE;
1465 }
1466 /* retry reading without getting new bytes or rewinding */
1467 skip_read = TRUE;
1468 goto retry;
1469 }
1470 }
1471
1472 /* Include not converted bytes. */
1473 ptr -= conv_restlen;
1474 size += conv_restlen;
1475 conv_restlen = 0;
1476 #endif
1477 /*
1478 * Break here for a read error or end-of-file.
1479 */
1480 if (size <= 0)
1481 break;
1482
1483 #ifdef FEAT_MBYTE
1484
1485 # ifdef USE_ICONV
1486 if (iconv_fd != (iconv_t)-1)
1487 {
1488 /*
1489 * Attempt conversion of the read bytes to 'encoding' using
1490 * iconv().
1491 */
1492 const char *fromp;
1493 char *top;
1494 size_t from_size;
1495 size_t to_size;
1496
1497 fromp = (char *)ptr;
1498 from_size = size;
1499 ptr += size;
1500 top = (char *)ptr;
1501 to_size = real_size - size;
1502
1503 /*
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).
1507 */
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)
1512 {
1513 if (can_retry)
1514 goto rewind_retry;
1515 if (conv_error == 0)
1516 conv_error = readfile_linenr(linecnt,
1517 ptr, (char_u *)top);
1518
1519 /* Deal with a bad byte and continue with the next. */
1520 ++fromp;
1521 --from_size;
1522 if (bad_char_behavior == BAD_KEEP)
1523 {
1524 *top++ = *(fromp - 1);
1525 --to_size;
1526 }
1527 else if (bad_char_behavior != BAD_DROP)
1528 {
1529 *top++ = bad_char_behavior;
1530 --to_size;
1531 }
1532 }
1533
1534 if (from_size > 0)
1535 {
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;
1540 }
1541
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);
1546 }
1547 # endif
1548
1549 # ifdef WIN3264
1550 if (fio_flags & FIO_CODEPAGE)
1551 {
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];
1559
1560 /*
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'
1566 *
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.
1570 */
1571
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;
1578
1579 /*
1580 * Move the bytes to the end of the buffer, so that we have
1581 * room to put the result at the start.
1582 */
1583 src = ptr + real_size - size;
1584 mch_memmove(src, ptr, size);
1585
1586 /*
1587 * Do the conversion.
1588 */
1589 dst = ptr;
1590 size = size;
1591 while (size > 0)
1592 {
1593 found_bad = FALSE;
1594
1595 # ifdef CP_UTF8 /* VC 4.1 doesn't define CP_UTF8 */
1596 if (codepage == CP_UTF8)
1597 {
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)
1603 {
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;
1609
1610 /* weird overlong byte sequence */
1611 bytelen = size;
1612 found_bad = TRUE;
1613 }
1614 else
1615 {
1616 int u8c = utf_ptr2char(src);
1617
1618 if (u8c > 0xffff || (*src >= 0x80 && bytelen == 1))
1619 found_bad = TRUE;
1620 ucs2buf[0] = u8c;
1621 ucs2len = 1;
1622 }
1623 }
1624 else
1625 # endif
1626 {
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)
1631 {
1632 ucs2len = MultiByteToWideChar(codepage,
1633 MB_ERR_INVALID_CHARS,
1634 (LPCSTR)src, bytelen,
1635 ucs2buf, 3);
1636 if (ucs2len > 0)
1637 break;
1638 }
1639 if (ucs2len == 0)
1640 {
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;
1648 }
1649 }
1650
1651 if (!found_bad)
1652 {
1653 int i;
1654
1655 /* Convert "ucs2buf[ucs2len]" to 'enc' in "dst". */
1656 if (enc_utf8)
1657 {
1658 /* From UCS-2 to UTF-8. Cannot fail. */
1659 for (i = 0; i < ucs2len; ++i)
1660 dst += utf_char2bytes(ucs2buf[i], dst);
1661 }
1662 else
1663 {
1664 BOOL bad = FALSE;
1665 int dstlen;
1666
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;
1678 }
1679 }
1680
1681 if (found_bad)
1682 {
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)
1689 {
1690 if (bad_char_behavior == BAD_KEEP)
1691 {
1692 mch_memmove(dst, src, bytelen);
1693 dst += bytelen;
1694 }
1695 else
1696 *dst++ = bad_char_behavior;
1697 }
1698 }
1699
1700 src += bytelen;
1701 size -= bytelen;
1702 }
1703
1704 if (size > 0)
1705 {
1706 /* An incomplete byte sequence remaining. */
1707 mch_memmove(conv_rest, src, size);
1708 conv_restlen = size;
1709 }
1710
1711 /* The new size is equal to how much "dst" was advanced. */
1712 size = (long)(dst - ptr);
1713 }
1714 else
1715 # endif
1716 # ifdef MACOS_CONVERT
1717 if (fio_flags & FIO_MACROMAN)
1718 {
1719 /*
1720 * Conversion from Apple MacRoman char encoding to UTF-8 or
1721 * latin1. This is in os_mac_conv.c.
1722 */
1723 if (macroman2enc(ptr, &size, real_size) == FAIL)
1724 goto rewind_retry;
1725 }
1726 else
1727 # endif
1728 if (fio_flags != 0)
1729 {
1730 int u8c;
1731 char_u *dest;
1732 char_u *tail = NULL;
1733
1734 /*
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.
1741 */
1742 dest = ptr + real_size;
1743 if (fio_flags == FIO_LATIN1 || fio_flags == FIO_UTF8)
1744 {
1745 p = ptr + size;
1746 if (fio_flags == FIO_UTF8)
1747 {
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;
1756 }
1757 }
1758 else if (fio_flags & (FIO_UCS2 | FIO_UTF16))
1759 {
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)
1765 {
1766 /* Check for a trailing leading word */
1767 if (fio_flags & FIO_ENDIAN_L)
1768 {
1769 u8c = (*--p << 8);
1770 u8c += *--p;
1771 }
1772 else
1773 {
1774 u8c = *--p;
1775 u8c += (*--p << 8);
1776 }
1777 if (u8c >= 0xd800 && u8c <= 0xdbff)
1778 tail = p;
1779 else
1780 p += 2;
1781 }
1782 }
1783 else /* FIO_UCS4 */
1784 {
1785 /* Check for trailing 1, 2 or 3 bytes */
1786 p = ptr + (size & ~3);
1787 if (size & 3)
1788 tail = p;
1789 }
1790
1791 /* If there is a trailing incomplete sequence move it to
1792 * conv_rest[]. */
1793 if (tail != NULL)
1794 {
1795 conv_restlen = (int)((ptr + size) - tail);
1796 mch_memmove(conv_rest, (char_u *)tail, conv_restlen);
1797 size -= conv_restlen;
1798 }
1799
1800
1801 while (p > ptr)
1802 {
1803 if (fio_flags & FIO_LATIN1)
1804 u8c = *--p;
1805 else if (fio_flags & (FIO_UCS2 | FIO_UTF16))
1806 {
1807 if (fio_flags & FIO_ENDIAN_L)
1808 {
1809 u8c = (*--p << 8);
1810 u8c += *--p;
1811 }
1812 else
1813 {
1814 u8c = *--p;
1815 u8c += (*--p << 8);
1816 }
1817 if ((fio_flags & FIO_UTF16)
1818 && u8c >= 0xdc00 && u8c <= 0xdfff)
1819 {
1820 int u16c;
1821
1822 if (p == ptr)
1823 {
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;
1834 }
1835
1836 /* found second word of double-word, get the first
1837 * word and compute the resulting character */
1838 if (fio_flags & FIO_ENDIAN_L)
1839 {
1840 u16c = (*--p << 8);
1841 u16c += *--p;
1842 }
1843 else
1844 {
1845 u16c = *--p;
1846 u16c += (*--p << 8);
1847 }
1848 u8c = 0x10000 + ((u16c & 0x3ff) << 10)
1849 + (u8c & 0x3ff);
1850
1851 /* Check if the word is indeed a leading word. */
1852 if (u16c < 0xd800 || u16c > 0xdbff)
1853 {
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;
1863 }
1864 }
1865 }
1866 else if (fio_flags & FIO_UCS4)
1867 {
1868 if (fio_flags & FIO_ENDIAN_L)
1869 {
1870 u8c = (*--p << 24);
1871 u8c += (*--p << 16);
1872 u8c += (*--p << 8);
1873 u8c += *--p;
1874 }
1875 else /* big endian */
1876 {
1877 u8c = *--p;
1878 u8c += (*--p << 8);
1879 u8c += (*--p << 16);
1880 u8c += (*--p << 24);
1881 }
1882 }
1883 else /* UTF-8 */
1884 {
1885 if (*--p < 0x80)
1886 u8c = *p;
1887 else
1888 {
1889 len = utf_head_off(ptr, p);
1890 p -= len;
1891 u8c = utf_ptr2char(p);
1892 if (len == 0)
1893 {
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;
1906 }
1907 }
1908 }
1909 if (enc_utf8) /* produce UTF-8 */
1910 {
1911 dest -= utf_char2len(u8c);
1912 (void)utf_char2bytes(u8c, dest);
1913 }
1914 else /* produce Latin1 */
1915 {
1916 --dest;
1917 if (u8c >= 0x100)
1918 {
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;
1934 }
1935 else
1936 *dest = u8c;
1937 }
1938 }
1939
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;
1945 }
1946 else if (enc_utf8 && !curbuf->b_p_bin)
1947 {
1948 int incomplete_tail = FALSE;
1949
1950 /* Reading UTF-8: Check if the bytes are valid UTF-8. */
1951 for (p = ptr; ; ++p)
1952 {
1953 int todo = (int)((ptr + size) - p);
1954 int l;
1955
1956 if (todo <= 0)
1957 break;
1958 if (*p >= 0x80)
1959 {
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)
1966 {
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)
1977 {
1978 conv_restlen = todo;
1979 mch_memmove(conv_rest, p, conv_restlen);
1980 size -= conv_restlen;
1981 break;
1982 }
1983 }
1984 if (l == 1 || l > todo)
1985 {
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);
1999
2000 /* Drop, keep or replace the bad byte. */
2001 if (bad_char_behavior == BAD_DROP)
2002 {
2003 mch_memmove(p, p + 1, todo - 1);
2004 --p;
2005 --size;
2006 }
2007 else if (bad_char_behavior != BAD_KEEP)
2008 *p = bad_char_behavior;
2009 }
2010 else
2011 p += l - 1;
2012 }
2013 }
2014 if (p < ptr + size && !incomplete_tail)
2015 {
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;
2029 }
2030 }
2031 #endif
2032
2033 /* count the number of characters (after conversion!) */
2034 filesize += size;
2035
2036 /*
2037 * when reading the first part of a file: guess EOL type
2038 */
2039 if (fileformat == EOL_UNKNOWN)
2040 {
2041 /* First try finding a NL, for Dos and Unix */
2042 if (try_dos || try_unix)
2043 {
2044 for (p = ptr; p < ptr + size; ++p)
2045 {
2046 if (*p == NL)
2047 {
2048 if (!try_unix
2049 || (try_dos && p > ptr && p[-1] == CAR))
2050 fileformat = EOL_DOS;
2051 else
2052 fileformat = EOL_UNIX;
2053 break;
2054 }
2055 }
2056
2057 /* Don't give in to EOL_UNIX if EOL_MAC is more likely */
2058 if (fileformat == EOL_UNIX && try_mac)
2059 {
2060 /* Need to reset the counters when retrying fenc. */
2061 try_mac = 1;
2062 try_unix = 1;
2063 for (; p >= ptr && *p != CAR; p--)
2064 ;
2065 if (p >= ptr)
2066 {
2067 for (p = ptr; p < ptr + size; ++p)
2068 {
2069 if (*p == NL)
2070 try_unix++;
2071 else if (*p == CAR)
2072 try_mac++;
2073 }
2074 if (try_mac > try_unix)
2075 fileformat = EOL_MAC;
2076 }
2077 }
2078 }
2079
2080 /* No NL found: may use Mac format */
2081 if (fileformat == EOL_UNKNOWN && try_mac)
2082 fileformat = EOL_MAC;
2083
2084 /* Still nothing found? Use first format in 'ffs' */
2085 if (fileformat == EOL_UNKNOWN)
2086 fileformat = default_fileformat();
2087
2088 /* if editing a new file: may set p_tx and p_ff */
2089 if (set_options)
2090 set_fileformat(fileformat, OPT_LOCAL);
2091 }
2092 }
2093
2094 /*
2095 * This loop is executed once for every character read.
2096 * Keep it fast!
2097 */
2098 if (fileformat == EOL_MAC)
2099 {
2100 --ptr;
2101 while (++ptr, --size >= 0)
2102 {
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
2111 {
2112 if (skip_count == 0)
2113 {
2114 *ptr = NUL; /* end of line */
2115 len = (colnr_T) (ptr - line_start + 1);
2116 if (ml_append(lnum, line_start, len, newfile) == FAIL)
2117 {
2118 error = TRUE;
2119 break;
2120 }
2121 ++lnum;
2122 if (--read_count == 0)
2123 {
2124 error = TRUE; /* break loop */
2125 line_start = ptr; /* nothing left to write */
2126 break;
2127 }
2128 }
2129 else
2130 --skip_count;
2131 line_start = ptr + 1;
2132 }
2133 }
2134 }
2135 else
2136 {
2137 --ptr;
2138 while (++ptr, --size >= 0)
2139 {
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
2145 {
2146 if (skip_count == 0)
2147 {
2148 *ptr = NUL; /* end of line */
2149 len = (colnr_T)(ptr - line_start + 1);
2150 if (fileformat == EOL_DOS)
2151 {
2152 if (ptr[-1] == CAR) /* remove CR */
2153 {
2154 ptr[-1] = NUL;
2155 --len;
2156 }
2157 /*
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.
2162 */
2163 else if (ff_error != EOL_DOS)
2164 {
2165 if ( try_unix
2166 && !read_stdin
2167 && (read_buffer
2168 || lseek(fd, (off_t)0L, SEEK_SET) == 0))
2169 {
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;
2176 }
2177 ff_error = EOL_DOS;
2178 }
2179 }
2180 if (ml_append(lnum, line_start, len, newfile) == FAIL)
2181 {
2182 error = TRUE;
2183 break;
2184 }
2185 ++lnum;
2186 if (--read_count == 0)
2187 {
2188 error = TRUE; /* break loop */
2189 line_start = ptr; /* nothing left to write */
2190 break;
2191 }
2192 }
2193 else
2194 --skip_count;
2195 line_start = ptr + 1;
2196 }
2197 }
2198 }
2199 linerest = (long)(ptr - line_start);
2200 ui_breakcheck();
2201 }
2202
2203 failed:
2204 /* not an error, max. number of lines reached */
2205 if (error && read_count == 0)
2206 error = FALSE;
2207
2208 /*
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.
2212 */
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))
2220 {
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;
2230 }
2231
2232 if (set_options)
2233 save_file_ff(curbuf); /* remember the current file format */
2234
2235 #ifdef FEAT_CRYPT
2236 if (cryptkey != curbuf->b_p_key)
2237 vim_free(cryptkey);
2238 #endif
2239
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)
2250 {
2251 iconv_close(iconv_fd);
2252 iconv_fd = (iconv_t)-1;
2253 }
2254 # endif
2255 #endif
2256
2257 if (!read_buffer && !read_stdin)
2258 close(fd); /* errors are ignored */
2259 #ifdef HAVE_FD_CLOEXEC
2260 else
2261 {
2262 int fdflags = fcntl(fd, F_GETFD);
2263 if (fdflags >= 0 && (fdflags & FD_CLOEXEC) == 0)
2264 fcntl(fd, F_SETFD, fdflags | FD_CLOEXEC);
2265 }
2266 #endif
2267 vim_free(buffer);
2268
2269 #ifdef HAVE_DUP
2270 if (read_stdin)
2271 {
2272 /* Use stderr for stdin, makes shell commands work. */
2273 close(0);
2274 ignored = dup(2);
2275 }
2276 #endif
2277
2278 #ifdef FEAT_MBYTE
2279 if (tmpname != NULL)
2280 {
2281 mch_remove(tmpname); /* delete converted file */
2282 vim_free(tmpname);
2283 }
2284 #endif
2285 --no_wait_return; /* may wait for return now */
2286
2287 /*
2288 * In recovery mode everything but autocommands is skipped.
2289 */
2290 if (!recoverymode)
2291 {
2292 /* need to delete the last line, which comes from the empty buffer */
2293 if (newfile && wasempty && !(curbuf->b_ml.ml_flags & ML_EMPTY))
2294 {
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;
2303 }
2304 linecnt = curbuf->b_ml.ml_line_count - linecnt;
2305 if (filesize == 0)
2306 linecnt = 0;
2307 if (newfile || read_buffer)
2308 {
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
2320 }
2321 else if (linecnt) /* appended at least one line */
2322 appended_lines_mark(from, linecnt);
2323
2324 #ifndef ALWAYS_USE_GUI
2325 /*
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.
2329 */
2330 if (read_stdin)
2331 {
2332 settmode(TMODE_RAW); /* set to raw mode */
2333 starttermcap();
2334 screenclear();
2335 }
2336 #endif
2337
2338 if (got_int)
2339 {
2340 if (!(flags & READ_DUMMY))
2341 {
2342 filemess(curbuf, sfname, (char_u *)_(e_interr), 0);
2343 if (newfile)
2344 curbuf->b_p_ro = TRUE; /* must use "w!" now */
2345 }
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 */
2351 }
2352
2353 if (!filtering && !(flags & READ_DUMMY))
2354 {
2355 msg_add_fname(curbuf, sfname); /* fname in IObuff with quotes */
2356 c = FALSE;
2357
2358 #ifdef UNIX
2359 # ifdef S_ISFIFO
2360 if (S_ISFIFO(perm)) /* fifo or socket */
2361 {
2362 STRCAT(IObuff, _("[fifo/socket]"));
2363 c = TRUE;
2364 }
2365 # else
2366 # ifdef S_IFIFO
2367 if ((perm & S_IFMT) == S_IFIFO) /* fifo */
2368 {
2369 STRCAT(IObuff, _("[fifo]"));
2370 c = TRUE;
2371 }
2372 # endif
2373 # ifdef S_IFSOCK
2374 if ((perm & S_IFMT) == S_IFSOCK) /* or socket */
2375 {
2376 STRCAT(IObuff, _("[socket]"));
2377 c = TRUE;
2378 }
2379 # endif
2380 # endif
2381 # ifdef OPEN_CHR_FILES
2382 if (S_ISCHR(perm)) /* or character special */
2383 {
2384 STRCAT(IObuff, _("[character special]"));
2385 c = TRUE;
2386 }
2387 # endif
2388 #endif
2389 if (curbuf->b_p_ro)
2390 {
2391 STRCAT(IObuff, shortmess(SHM_RO) ? _("[RO]") : _("[readonly]"));
2392 c = TRUE;
2393 }
2394 if (read_no_eol_lnum)
2395 {
2396 msg_add_eol();
2397 c = TRUE;
2398 }
2399 if (ff_error == EOL_DOS)
2400 {
2401 STRCAT(IObuff, _("[CR missing]"));
2402 c = TRUE;
2403 }
2404 if (split)
2405 {
2406 STRCAT(IObuff, _("[long lines split]"));
2407 c = TRUE;
2408 }
2409 #ifdef FEAT_MBYTE
2410 if (notconverted)
2411 {
2412 STRCAT(IObuff, _("[NOT converted]"));
2413 c = TRUE;
2414 }
2415 else if (converted)
2416 {
2417 STRCAT(IObuff, _("[converted]"));
2418 c = TRUE;
2419 }
2420 #endif
2421 #ifdef FEAT_CRYPT
2422 if (cryptkey != NULL)
2423 {
2424 STRCAT(IObuff, _("[crypted]"));
2425 c = TRUE;
2426 }
2427 #endif
2428 #ifdef FEAT_MBYTE
2429 if (conv_error != 0)
2430 {
2431 sprintf((char *)IObuff + STRLEN(IObuff),
2432 _("[CONVERSION ERROR in line %ld]"), (long)conv_error);
2433 c = TRUE;
2434 }
2435 else if (illegal_byte > 0)
2436 {
2437 sprintf((char *)IObuff + STRLEN(IObuff),
2438 _("[ILLEGAL BYTE in line %ld]"), (long)illegal_byte);
2439 c = TRUE;
2440 }
2441 else
2442 #endif
2443 if (error)
2444 {
2445 STRCAT(IObuff, _("[READ ERRORS]"));
2446 c = TRUE;
2447 }
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);
2456
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;
2478 }
2479
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
2486 ))
2487 curbuf->b_p_ro = TRUE;
2488
2489 u_clearline(); /* cannot use "U" command after adding lines */
2490
2491 /*
2492 * In Ex mode: cursor at last new line.
2493 * Otherwise: cursor at first new line.
2494 */
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 */
2501
2502 /*
2503 * Set '[ and '] marks to the newly read lines.
2504 */
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;
2509
2510 #ifdef WIN32
2511 /*
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.
2517 */
2518 if (newfile && !read_stdin && !read_buffer
2519 && mch_stat((char *)fname, &st) >= 0)
2520 {
2521 buf_store_time(curbuf, &st, fname);
2522 curbuf->b_mtime_read = curbuf->b_mtime;
2523 }
2524 #endif
2525 }
2526 msg_scroll = msg_save;
2527
2528 #ifdef FEAT_VIMINFO
2529 /*
2530 * Get the marks before executing autocommands, so they can be used there.
2531 */
2532 check_marks_read();
2533 #endif
2534
2535 /*
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.
2539 */
2540 write_no_eol_lnum = read_no_eol_lnum;
2541
2542 #ifdef FEAT_AUTOCMD
2543 if (!read_stdin && !read_buffer)
2544 {
2545 int m = msg_scroll;
2546 int n = msg_scrolled;
2547
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);
2552
2553 /*
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.
2557 */
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
2574 }
2575 #endif
2576
2577 if (recoverymode && error)
2578 return FAIL;
2579 return OK;
2580 }
2581
2582 #ifdef OPEN_CHR_FILES
2583 /*
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.
2588 */
2589 static int
2590 is_dev_fd_file(fname)
2591 char_u *fname;
2592 {
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')));
2598 }
2599 #endif
2600
2601 #ifdef FEAT_MBYTE
2602
2603 /*
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.
2607 */
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 */
2613 {
2614 char_u *s;
2615 linenr_T lnum;
2616
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;
2622 }
2623 #endif
2624
2625 /*
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.
2629 */
2630 int
2631 prep_exarg(eap, buf)
2632 exarg_T *eap;
2633 buf_T *buf;
2634 {
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;
2642
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;
2651
2652 eap->force_bin = buf->b_p_bin ? FORCE_BIN : FORCE_NOBIN;
2653 eap->read_edit = FALSE;
2654 eap->forceit = FALSE;
2655 return OK;
2656 }
2657
2658 #ifdef FEAT_MBYTE
2659 /*
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.
2665 */
2666 static char_u *
2667 next_fenc(pp)
2668 char_u **pp;
2669 {
2670 char_u *p;
2671 char_u *r;
2672
2673 if (**pp == NUL)
2674 {
2675 *pp = NULL;
2676 return (char_u *)"";
2677 }
2678 p = vim_strchr(*pp, ',');
2679 if (p == NULL)
2680 {
2681 r = enc_canonize(*pp);
2682 *pp += STRLEN(*pp);
2683 }
2684 else
2685 {
2686 r = vim_strnsave(*pp, (int)(p - *pp));
2687 *pp = p + 1;
2688 if (r != NULL)
2689 {
2690 p = enc_canonize(r);
2691 vim_free(r);
2692 r = p;
2693 }
2694 }
2695 if (r == NULL) /* out of memory */
2696 {
2697 r = (char_u *)"";
2698 *pp = NULL;
2699 }
2700 return r;
2701 }
2702
2703 # ifdef FEAT_EVAL
2704 /*
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) .
2711 */
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 */
2717 {
2718 char_u *tmpname;
2719 char_u *errmsg = NULL;
2720
2721 tmpname = vim_tempname('r');
2722 if (tmpname == NULL)
2723 errmsg = (char_u *)_("Can't find temp file for conversion");
2724 else
2725 {
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'");
2734 }
2735
2736 if (errmsg != NULL)
2737 {
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)
2742 {
2743 mch_remove(tmpname); /* delete converted file */
2744 vim_free(tmpname);
2745 tmpname = NULL;
2746 }
2747 }
2748
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);
2752
2753 return tmpname;
2754 }
2755 # endif
2756
2757 #endif
2758
2759 #ifdef FEAT_VIMINFO
2760 /*
2761 * Read marks for the current buffer from the viminfo file, when we support
2762 * buffer marks and the buffer has a name.
2763 */
2764 static void
2765 check_marks_read()
2766 {
2767 if (!curbuf->b_marks_read && get_viminfo_parameter('\'') > 0
2768 && curbuf->b_ffname != NULL)
2769 read_viminfo(NULL, VIF_WANT_MARKS);
2770
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;
2774 }
2775 #endif
2776
2777 #ifdef FEAT_CRYPT
2778 /*
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.
2783 */
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 */
2791 {
2792 if (*sizep >= CRYPT_MAGIC_LEN
2793 && STRNCMP(ptr, CRYPT_MAGIC, CRYPT_MAGIC_LEN) == 0)
2794 {
2795 if (cryptkey == NULL)
2796 {
2797 if (*curbuf->b_p_key)
2798 cryptkey = curbuf->b_p_key;
2799 else
2800 {
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)
2806 {
2807 if (cryptkey != curbuf->b_p_key)
2808 vim_free(cryptkey);
2809 cryptkey = NULL;
2810 }
2811 }
2812 }
2813
2814 if (cryptkey != NULL)
2815 {
2816 crypt_init_keys(cryptkey);
2817
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);
2822 }
2823 }
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);
2829
2830 return cryptkey;
2831 }
2832 #endif
2833
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 */
2840 {
2841 # if defined(HAVE_UTIME) && defined(HAVE_UTIME_H)
2842 struct utimbuf buf;
2843
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];
2850
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
2862 }
2863 #endif /* UNIX */
2864
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
2869
2870 /*
2871 * Return TRUE if a file appears to be read-only from the file permissions.
2872 */
2873 int
2874 check_file_readonly(fname, perm)
2875 char_u *fname; /* full path to file */
2876 int perm; /* known permissions on file */
2877 {
2878 #ifndef USE_MCH_ACCESS
2879 int fd = 0;
2880 #endif
2881
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
2892 );
2893 }
2894
2895
2896 /*
2897 * buf_write() - write to file "fname" lines "start" through "end"
2898 *
2899 * We do our own buffering here because fwrite() is so slow.
2900 *
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.
2904 *
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.
2907 *
2908 * This function must NOT use NameBuff (because it's called by autowrite()).
2909 *
2910 * return FAIL for failure, OK otherwise
2911 */
2912 int
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;
2925 {
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
2981
2982 if (fname == NULL || *fname == NUL) /* safety check */
2983 return FAIL;
2984 if (buf->b_ml.ml_mfp == NULL)
2985 {
2986 /* This can happen during startup when there is a stray "w" in the
2987 * vimrc file. */
2988 EMSG(_(e_emptybuf));
2989 return FAIL;
2990 }
2991
2992 /*
2993 * Disallow writing from .exrc and .vimrc in current directory for
2994 * security reasons.
2995 */
2996 if (check_secure())
2997 return FAIL;
2998
2999 /* Avoid a crash for a long name. */
3000 if (STRLEN(fname) >= MAXPATHL)
3001 {
3002 EMSG(_(e_longname));
3003 return FAIL;
3004 }
3005
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
3016
3017 /* After writing a file changedtick changes but we don't want to display
3018 * the line. */
3019 ex_no_reprint = TRUE;
3020
3021 /*
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.
3027 */
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)
3038 {
3039 if (set_rw_fname(fname, sfname) == FAIL)
3040 return FAIL;
3041 buf = curbuf; /* just in case autocmds made "buf" invalid */
3042 }
3043
3044 if (sfname == NULL)
3045 sfname = fname;
3046 /*
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
3051 */
3052 ffname = fname; /* remember full fname */
3053 #ifdef UNIX
3054 fname = sfname;
3055 #endif
3056
3057 if (buf->b_ffname != NULL && fnamecmp(ffname, buf->b_ffname) == 0)
3058 overwriting = TRUE;
3059 else
3060 overwriting = FALSE;
3061
3062 if (exiting)
3063 settmode(TMODE_COOK); /* when exiting allow typahead now */
3064
3065 ++no_wait_return; /* don't wait for return yet */
3066
3067 /*
3068 * Set '[ and '] marks to the lines to be written.
3069 */
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;
3074
3075 #ifdef FEAT_AUTOCMD
3076 {
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);
3085
3086 /*
3087 * Apply PRE aucocommands.
3088 * Set curbuf to the buffer to be written.
3089 * Careful: The autocommands may call buf_write() recursively!
3090 */
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;
3099
3100 /* set curwin/curbuf to buf and save a few things */
3101 aucmd_prepbuf(&aco, buf);
3102
3103 if (append)
3104 {
3105 if (!(did_cmd = apply_autocmds_exarg(EVENT_FILEAPPENDCMD,
3106 sfname, sfname, FALSE, curbuf, eap)))
3107 {
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);
3115 }
3116 }
3117 else if (filtering)
3118 {
3119 apply_autocmds_exarg(EVENT_FILTERWRITEPRE,
3120 NULL, sfname, FALSE, curbuf, eap);
3121 }
3122 else if (reset_changed && whole)
3123 {
3124 if (!(did_cmd = apply_autocmds_exarg(EVENT_BUFWRITECMD,
3125 sfname, sfname, FALSE, curbuf, eap)))
3126 {
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);
3134 }
3135 }
3136 else
3137 {
3138 if (!(did_cmd = apply_autocmds_exarg(EVENT_FILEWRITECMD,
3139 sfname, sfname, FALSE, curbuf, eap)))
3140 {
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);
3148 }
3149 }
3150
3151 /* restore curwin/curbuf and a few other things */
3152 aucmd_restbuf(&aco);
3153
3154 /*
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.
3159 */
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
3167 )
3168 {
3169 --no_wait_return;
3170 msg_scroll = msg_save;
3171 if (nofile_err)
3172 EMSG(_("E676: No matching autocommands for acwrite buffer"));
3173
3174 if (nofile_err
3175 #ifdef FEAT_EVAL
3176 || aborting()
3177 #endif
3178 )
3179 /* An aborting error, interrupt or exception in the
3180 * autocommands. */
3181 return FAIL;
3182 if (did_cmd)
3183 {
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)
3189 {
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;
3196 }
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;
3203 }
3204 #ifdef FEAT_EVAL
3205 if (!aborting())
3206 #endif
3207 EMSG(_("E203: Autocommands deleted or unloaded buffer to be written"));
3208 return FAIL;
3209 }
3210
3211 /*
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!).
3216 */
3217 if (buf->b_ml.ml_line_count != old_line_count)
3218 {
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 */
3224 {
3225 end -= old_line_count - buf->b_ml.ml_line_count;
3226 if (end < start)
3227 {
3228 --no_wait_return;
3229 msg_scroll = msg_save;
3230 EMSG(_("E204: Autocommand changed number of lines in unexpected way"));
3231 return FAIL;
3232 }
3233 }
3234 }
3235
3236 /*
3237 * The autocommands may have changed the name of the buffer, which may
3238 * be kept in fname, ffname and sfname.
3239 */
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;
3248 }
3249 #endif
3250
3251 #ifdef FEAT_NETBEANS_INTG
3252 if (usingNetbeans && isNetbeansBuffer(buf))
3253 {
3254 if (whole)
3255 {
3256 /*
3257 * b_changed can be 0 after an undo, but we still need to write
3258 * the buffer to NetBeans.
3259 */
3260 if (buf->b_changed || isNetbeansModified(buf))
3261 {
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;
3266 }
3267 else
3268 {
3269 errnum = (char_u *)"E656: ";
3270 errmsg = (char_u *)_("NetBeans disallows writes of unmodified buffers");
3271 buffer = NULL;
3272 goto fail;
3273 }
3274 }
3275 else
3276 {
3277 errnum = (char_u *)"E657: ";
3278 errmsg = (char_u *)_("Partial writes disallowed for NetBeans buffers");
3279 buffer = NULL;
3280 goto fail;
3281 }
3282 }
3283 #endif
3284
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 */
3298
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) */
3303 {
3304 buffer = smallbuf;
3305 bufsize = SMBUFSIZE;
3306 }
3307 else
3308 bufsize = BUFSIZE;
3309
3310 /*
3311 * Get information about original file (if there is one).
3312 */
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
3320 {
3321 perm = st_old.st_mode;
3322 if (!S_ISREG(st_old.st_mode)) /* not a file */
3323 {
3324 if (S_ISDIR(st_old.st_mode))
3325 {
3326 errnum = (char_u *)"E502: ";
3327 errmsg = (char_u *)_("is a directory");
3328 goto fail;
3329 }
3330 if (mch_nodetype(fname) != NODE_WRITABLE)
3331 {
3332 errnum = (char_u *)"E503: ";
3333 errmsg = (char_u *)_("is not a file or writable device");
3334 goto fail;
3335 }
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;
3341 }
3342 }
3343 #else /* !UNIX */
3344 /*
3345 * Check for a writable device name.
3346 */
3347 c = mch_nodetype(fname);
3348 if (c == NODE_OTHER)
3349 {
3350 errnum = (char_u *)"E503: ";
3351 errmsg = (char_u *)_("is not a file or writable device");
3352 goto fail;
3353 }
3354 if (c == NODE_WRITABLE)
3355 {
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)
3360 {
3361 errnum = (char_u *)"E796: ";
3362 errmsg = (char_u *)_("writing to device disabled with 'opendevice' option");
3363 goto fail;
3364 }
3365 # endif
3366 device = TRUE;
3367 newfile = TRUE;
3368 perm = -1;
3369 }
3370 else
3371 {
3372 perm = mch_getperm(fname);
3373 if (perm < 0)
3374 newfile = TRUE;
3375 else if (mch_isdir(fname))
3376 {
3377 errnum = (char_u *)"E502: ";
3378 errmsg = (char_u *)_("is a directory");
3379 goto fail;
3380 }
3381 if (overwriting)
3382 (void)mch_stat((char *)fname, &st_old);
3383 }
3384 #endif /* !UNIX */
3385
3386 if (!device && !newfile)
3387 {
3388 /*
3389 * Check if the file is really writable (when renaming the file to
3390 * make a backup we won't discover it later).
3391 */
3392 file_readonly = check_file_readonly(fname, (int)perm);
3393
3394 if (!forceit && file_readonly)
3395 {
3396 if (vim_strchr(p_cpo, CPO_FWRITE) != NULL)
3397 {
3398 errnum = (char_u *)"E504: ";
3399 errmsg = (char_u *)_(err_readonly);
3400 }
3401 else
3402 {
3403 errnum = (char_u *)"E505: ";
3404 errmsg = (char_u *)_("is read-only (add ! to override)");
3405 }
3406 goto fail;
3407 }
3408
3409 /*
3410 * Check if the timestamp hasn't changed since reading the file.
3411 */
3412 if (overwriting)
3413 {
3414 retval = check_mtime(buf, &st_old);
3415 if (retval == FAIL)
3416 goto fail;
3417 }
3418 }
3419
3420 #ifdef HAVE_ACL
3421 /*
3422 * For systems that support ACL: get the ACL from the original file.
3423 */
3424 if (!newfile)
3425 acl = mch_get_acl(fname);
3426 #endif
3427
3428 /*
3429 * If 'backupskip' is not empty, don't make a backup for some files.
3430 */
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
3436
3437 /*
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.
3441 */
3442 prev_got_int = got_int;
3443 got_int = FALSE;
3444
3445 /* Mark the buffer as 'being saved' to prevent changed buffer warnings */
3446 buf->b_saving = TRUE;
3447
3448 /*
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.
3452 *
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.
3455 */
3456 if (!(append && *p_pm == NUL) && !filtering && perm >= 0 && dobackup)
3457 {
3458 #if defined(UNIX) || defined(WIN32)
3459 struct stat st;
3460 #endif
3461
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" */
3466 {
3467 int i;
3468
3469 # ifdef UNIX
3470 /*
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
3476 */
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
3485 )
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
3496 {
3497 /*
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).
3502 */
3503 STRCPY(IObuff, fname);
3504 for (i = 4913; ; i += 123)
3505 {
3506 sprintf((char *)gettail(IObuff), "%d", i);
3507 if (mch_lstat((char *)IObuff, &st) < 0)
3508 break;
3509 }
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
3515 {
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);
3530 }
3531 }
3532 }
3533
3534 # ifdef UNIX
3535 /*
3536 * Break symlinks and/or hardlinks if we've been asked to.
3537 */
3538 if ((bkc_flags & BKC_BREAKSYMLINK) || (bkc_flags & BKC_BREAKHARDLINK))
3539 {
3540 int lstat_res;
3541
3542 lstat_res = mch_lstat((char *)fname, &st);
3543
3544 /* Symlinks. */
3545 if ((bkc_flags & BKC_BREAKSYMLINK)
3546 && lstat_res == 0
3547 && st.st_ino != st_old.st_ino)
3548 backup_copy = FALSE;
3549
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;
3555 }
3556 #endif
3557
3558 #endif
3559
3560 /* make sure we have a valid backup extension to use */
3561 if (*p_bex == NUL)
3562 {
3563 #ifdef RISCOS
3564 backup_ext = (char_u *)"/bak";
3565 #else
3566 backup_ext = (char_u *)".bak";
3567 #endif
3568 }
3569 else
3570 backup_ext = p_bex;
3571
3572 if (backup_copy
3573 && (fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0)) >= 0)
3574 {
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
3584
3585 copybuf = alloc(BUFSIZE + 1);
3586 if (copybuf == NULL)
3587 {
3588 some_error = TRUE; /* out of memory */
3589 goto nobackup;
3590 }
3591
3592 /*
3593 * Try to make the backup in each directory in the 'bdir' option.
3594 *
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.
3600 *
3601 * For these reasons, the existing writable file must be truncated
3602 * and reused. Creation of a backup COPY will be attempted.
3603 */
3604 dirp = p_bdir;
3605 while (*dirp)
3606 {
3607 #ifdef UNIX
3608 st_new.st_ino = 0;
3609 st_new.st_dev = 0;
3610 st_new.st_gid = 0;
3611 #endif
3612
3613 /*
3614 * Isolate one directory name, using an entry in 'bdir'.
3615 */
3616 (void)copy_option_part(&dirp, copybuf, BUFSIZE, ",");
3617 rootname = get_file_in_dir(fname, copybuf);
3618 if (rootname == NULL)
3619 {
3620 some_error = TRUE; /* out of memory */
3621 goto nobackup;
3622 }
3623
3624 #if defined(UNIX) && !defined(SHORT_FNAME)
3625 did_set_shortname = FALSE;
3626 #endif
3627
3628 /*
3629 * May try twice if 'shortname' not set.
3630 */
3631 for (;;)
3632 {
3633 /*
3634 * Make backup file name.
3635 */
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)
3644 {
3645 vim_free(rootname);
3646 some_error = TRUE; /* out of memory */
3647 goto nobackup;
3648 }
3649
3650 /*
3651 * Check if backup file already exists.
3652 */
3653 if (mch_stat((char *)backup, &st_new) >= 0)
3654 {
3655 #ifdef UNIX
3656 /*
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.
3662 */
3663 if (st_new.st_dev == st_old.st_dev
3664 && st_new.st_ino == st_old.st_ino)
3665 {
3666 vim_free(backup);
3667 backup = NULL; /* no backup file to delete */
3668 # ifndef SHORT_FNAME
3669 /*
3670 * may try again with 'shortname' set
3671 */
3672 if (!(buf->b_shortname || buf->b_p_sn))
3673 {
3674 buf->b_shortname = TRUE;
3675 did_set_shortname = TRUE;
3676 continue;
3677 }
3678 /* setting shortname didn't help */
3679 if (did_set_shortname)
3680 buf->b_shortname = FALSE;
3681 # endif
3682 break;
3683 }
3684 #endif
3685
3686 /*
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.
3690 */
3691 if (!p_bk)
3692 {
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')
3703 {
3704 vim_free(backup);
3705 backup = NULL;
3706 }
3707 }
3708 }
3709 break;
3710 }
3711 vim_free(rootname);
3712
3713 /*
3714 * Try to create the backup file
3715 */
3716 if (backup != NULL)
3717 {
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)
3726 {
3727 vim_free(backup);
3728 backup = NULL;
3729 }
3730 else
3731 {
3732 /* set file protection same as original file, but
3733 * strip s-bit */
3734 (void)mch_setperm(backup, perm & 0777);
3735
3736 #ifdef UNIX
3737 /*
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.
3742 */
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
3747 )
3748 mch_setperm(backup,
3749 (perm & 0707) | ((perm & 07) << 3));
3750 # ifdef HAVE_SELINUX
3751 mch_copy_sec(fname, backup);
3752 # endif
3753 #endif
3754
3755 /*
3756 * copy the file.
3757 */
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)
3765 {
3766 if (buf_write_bytes(&write_info) == FAIL)
3767 {
3768 errmsg = (char_u *)_("E506: Can't write to backup file (add ! to override)");
3769 break;
3770 }
3771 ui_breakcheck();
3772 if (got_int)
3773 {
3774 errmsg = (char_u *)_(e_interr);
3775 break;
3776 }
3777 }
3778
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;
3793 }
3794 }
3795 }
3796 nobackup:
3797 close(fd); /* ignore errors for closing read file */
3798 vim_free(copybuf);
3799
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)
3804 {
3805 retval = FAIL;
3806 goto fail;
3807 }
3808 errmsg = NULL;
3809 }
3810 else
3811 {
3812 char_u *dirp;
3813 char_u *p;
3814 char_u *rootname;
3815
3816 /*
3817 * Make a backup by renaming the original file.
3818 */
3819 /*
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.
3823 */
3824 if (file_readonly && vim_strchr(p_cpo, CPO_FWRITE) != NULL)
3825 {
3826 errnum = (char_u *)"E504: ";
3827 errmsg = (char_u *)_(err_readonly);
3828 goto fail;
3829 }
3830
3831 /*
3832 *
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.
3836 */
3837 dirp = p_bdir;
3838 while (*dirp)
3839 {
3840 /*
3841 * Isolate one directory name and make the backup file name.
3842 */
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
3848 {
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);
3857 }
3858
3859 if (backup != NULL)
3860 {
3861 /*
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.
3865 */
3866 if (!p_bk && mch_getperm(backup) >= 0)
3867 {
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')
3876 {
3877 vim_free(backup);
3878 backup = NULL;
3879 }
3880 }
3881 }
3882 if (backup != NULL)
3883 {
3884 /*
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.
3889 */
3890 /*
3891 * If the renaming of the original file to the backup file
3892 * works, quit here.
3893 */
3894 if (vim_rename(fname, backup) == 0)
3895 break;
3896
3897 vim_free(backup); /* don't do the rename below */
3898 backup = NULL;
3899 }
3900 }
3901 if (backup == NULL && !forceit)
3902 {
3903 errmsg = (char_u *)_("E510: Can't make backup file (add ! to override)");
3904 goto fail;
3905 }
3906 }
3907 }
3908
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)
3913 {
3914 perm |= 0200;
3915 (void)mch_setperm(fname, perm);
3916 made_writable = TRUE;
3917 }
3918 #endif
3919
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)
3923 {
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
3931 }
3932
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;
3937
3938 /*
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.
3944 */
3945 if (reset_changed && !newfile && overwriting
3946 && !(exiting && backup != NULL))
3947 {
3948 ml_preserve(buf, FALSE);
3949 if (got_int)
3950 {
3951 errmsg = (char_u *)_(e_interr);
3952 goto restore_backup;
3953 }
3954 }
3955
3956 #ifdef MACOS_CLASSIC /* TODO: Is it need for MACOS_X? (Dany) */
3957 /*
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.
3961 */
3962 if (backup == NULL && overwriting && !append)
3963 if (mch_has_resource_fork(fname))
3964 {
3965 errmsg = (char_u *)_("E460: The resource fork would be lost (add ! to override)");
3966 goto restore_backup;
3967 }
3968 #endif
3969
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;
3976
3977 #ifdef FEAT_MBYTE
3978 /* Check for forced 'fileencoding' from "++opt=val" argument. */
3979 if (eap != NULL && eap->force_enc != 0)
3980 {
3981 fenc = eap->cmd + eap->force_enc;
3982 fenc = enc_canonize(fenc);
3983 fenc_tofree = fenc;
3984 }
3985 else
3986 fenc = buf->b_p_fenc;
3987
3988 /*
3989 * Check if the file needs to be converted.
3990 */
3991 converted = need_conversion(fenc);
3992
3993 /*
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.
3997 */
3998 if (converted && (enc_utf8 || STRCMP(p_enc, "latin1") == 0))
3999 {
4000 wb_flags = get_fio_flags(fenc);
4001 if (wb_flags & (FIO_UCS2 | FIO_UCS4 | FIO_UTF16 | FIO_UTF8))
4002 {
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;
4012 }
4013 }
4014
4015 # ifdef WIN3264
4016 if (converted && wb_flags == 0 && (wb_flags = get_win_fio_flags(fenc)) != 0)
4017 {
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;
4024 }
4025 # endif
4026
4027 # ifdef MACOS_X
4028 if (converted && wb_flags == 0 && (wb_flags = get_mac_fio_flags(fenc)) != 0)
4029 {
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;
4035 }
4036 # endif
4037
4038 # if defined(FEAT_EVAL) || defined(USE_ICONV)
4039 if (converted && wb_flags == 0)
4040 {
4041 # ifdef USE_ICONV
4042 /*
4043 * Use iconv() conversion when conversion is needed and it's not done
4044 * internally.
4045 */
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)
4049 {
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;
4057 }
4058 # ifdef FEAT_EVAL
4059 else
4060 # endif
4061 # endif
4062
4063 # ifdef FEAT_EVAL
4064 /*
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.
4068 */
4069 if (*p_ccv != NUL)
4070 {
4071 wfname = vim_tempname('w');
4072 if (wfname == NULL) /* Can't write without a tempfile! */
4073 {
4074 errmsg = (char_u *)_("E214: Can't find temp file for writing");
4075 goto restore_backup;
4076 }
4077 }
4078 # endif
4079 }
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
4088 )
4089 {
4090 if (!forceit)
4091 {
4092 errmsg = (char_u *)_("E213: Cannot convert (add ! to write without conversion)");
4093 goto restore_backup;
4094 }
4095 notconverted = TRUE;
4096 }
4097 #endif
4098
4099 /*
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.
4106 */
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)
4111 {
4112 /*
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.
4116 */
4117 if (errmsg == NULL)
4118 {
4119 #ifdef UNIX
4120 struct stat st;
4121
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
4130 {
4131 errmsg = (char_u *)_("E212: Can't open file for writing");
4132 if (forceit && vim_strchr(p_cpo, CPO_FWRITE) == NULL
4133 && perm >= 0)
4134 {
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;
4147 }
4148 }
4149 }
4150
4151 restore_backup:
4152 {
4153 struct stat st;
4154
4155 /*
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.
4159 */
4160 if (backup != NULL && wfname == fname)
4161 {
4162 if (backup_copy)
4163 {
4164 /*
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.
4169 */
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);
4176 }
4177 else
4178 {
4179 /* try to put the original file back */
4180 vim_rename(backup, fname);
4181 }
4182 }
4183
4184 /* if original file no longer exists give an extra warning */
4185 if (!newfile && mch_stat((char *)fname, &st) < 0)
4186 end = 0;
4187 }
4188
4189 #ifdef FEAT_MBYTE
4190 if (wfname != fname)
4191 vim_free(wfname);
4192 #endif
4193 goto fail;
4194 }
4195 errmsg = NULL;
4196
4197 #if defined(MACOS_CLASSIC) || defined(WIN3264)
4198 /* TODO: Is it need for MACOS_X? (Dany) */
4199 /*
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)
4203 */
4204 if (backup != NULL && overwriting && !append)
4205 {
4206 if (backup_copy)
4207 (void)mch_copy_file_attribute(wfname, backup);
4208 else
4209 (void)mch_copy_file_attribute(backup, wfname);
4210 }
4211
4212 if (!overwriting && !append)
4213 {
4214 if (buf->b_ffname != NULL)
4215 (void)mch_copy_file_attribute(buf->b_ffname, wfname);
4216 /* Should copy resource fork */
4217 }
4218 #endif
4219
4220 write_info.bw_fd = fd;
4221
4222 #ifdef FEAT_CRYPT
4223 if (*buf->b_p_key && !filtering)
4224 {
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 = (char_u *)CRYPT_MAGIC;
4230 write_info.bw_len = CRYPT_MAGIC_LEN;
4231 write_info.bw_flags = FIO_NOCONVERT;
4232 if (buf_write_bytes(&write_info) == FAIL)
4233 end = 0;
4234 wb_flags |= FIO_ENCRYPTED;
4235 }
4236 #endif
4237
4238 write_info.bw_buf = buffer;
4239 nchars = 0;
4240
4241 /* use "++bin", "++nobin" or 'binary' */
4242 if (eap != NULL && eap->force_bin != 0)
4243 write_bin = (eap->force_bin == FORCE_BIN);
4244 else
4245 write_bin = buf->b_p_bin;
4246
4247 #ifdef FEAT_MBYTE
4248 /*
4249 * The BOM is written just after the encryption magic number.
4250 * Skip it when appending and the file already existed, the BOM only makes
4251 * sense at the start of the file.
4252 */
4253 if (buf->b_p_bomb && !write_bin && (!append || perm < 0))
4254 {
4255 write_info.bw_len = make_bom(buffer, fenc);
4256 if (write_info.bw_len > 0)
4257 {
4258 /* don't convert, do encryption */
4259 write_info.bw_flags = FIO_NOCONVERT | wb_flags;
4260 if (buf_write_bytes(&write_info) == FAIL)
4261 end = 0;
4262 else
4263 nchars += write_info.bw_len;
4264 }
4265 }
4266 write_info.bw_start_lnum = start;
4267 #endif
4268
4269 write_info.bw_len = bufsize;
4270 #ifdef HAS_BW_FLAGS
4271 write_info.bw_flags = wb_flags;
4272 #endif
4273 fileformat = get_fileformat_force(buf, eap);
4274 s = buffer;
4275 len = 0;
4276 for (lnum = start; lnum <= end; ++lnum)
4277 {
4278 /*
4279 * The next while loop is done once for each character written.
4280 * Keep it fast!
4281 */
4282 ptr = ml_get_buf(buf, lnum, FALSE) - 1;
4283 while ((c = *++ptr) != NUL)
4284 {
4285 if (c == NL)
4286 *s = NUL; /* replace newlines with NULs */
4287 else if (c == CAR && fileformat == EOL_MAC)
4288 *s = NL; /* Mac: replace CRs with NLs */
4289 else
4290 *s = c;
4291 ++s;
4292 if (++len != bufsize)
4293 continue;
4294 if (buf_write_bytes(&write_info) == FAIL)
4295 {
4296 end = 0; /* write error: break loop */
4297 break;
4298 }
4299 nchars += bufsize;
4300 s = buffer;
4301 len = 0;
4302 #ifdef FEAT_MBYTE
4303 write_info.bw_start_lnum = lnum;
4304 #endif
4305 }
4306 /* write failed or last line has no EOL: stop here */
4307 if (end == 0
4308 || (lnum == end
4309 && write_bin
4310 && (lnum == write_no_eol_lnum
4311 || (lnum == buf->b_ml.ml_line_count && !buf->b_p_eol))))
4312 {
4313 ++lnum; /* written the line, count it */
4314 no_eol = TRUE;
4315 break;
4316 }
4317 if (fileformat == EOL_UNIX)
4318 *s++ = NL;
4319 else
4320 {
4321 *s++ = CAR; /* EOL_MAC or EOL_DOS: write CR */
4322 if (fileformat == EOL_DOS) /* write CR-NL */
4323 {
4324 if (++len == bufsize)
4325 {
4326 if (buf_write_bytes(&write_info) == FAIL)
4327 {
4328 end = 0; /* write error: break loop */
4329 break;
4330 }
4331 nchars += bufsize;
4332 s = buffer;
4333 len = 0;
4334 }
4335 *s++ = NL;
4336 }
4337 }
4338 if (++len == bufsize && end)
4339 {
4340 if (buf_write_bytes(&write_info) == FAIL)
4341 {
4342 end = 0; /* write error: break loop */
4343 break;
4344 }
4345 nchars += bufsize;
4346 s = buffer;
4347 len = 0;
4348
4349 ui_breakcheck();
4350 if (got_int)
4351 {
4352 end = 0; /* Interrupted, break loop */
4353 break;
4354 }
4355 }
4356 #ifdef VMS
4357 /*
4358 * On VMS there is a problem: newlines get added when writing blocks
4359 * at a time. Fix it by writing a line at a time.
4360 * This is much slower!
4361 * Explanation: VAX/DECC RTL insists that records in some RMS
4362 * structures end with a newline (carriage return) character, and if
4363 * they don't it adds one.
4364 * With other RMS structures it works perfect without this fix.
4365 */
4366 if (buf->b_fab_rfm == FAB$C_VFC
4367 || ((buf->b_fab_rat & (FAB$M_FTN | FAB$M_CR)) != 0))
4368 {
4369 int b2write;
4370
4371 buf->b_fab_mrs = (buf->b_fab_mrs == 0
4372 ? MIN(4096, bufsize)
4373 : MIN(buf->b_fab_mrs, bufsize));
4374
4375 b2write = len;
4376 while (b2write > 0)
4377 {
4378 write_info.bw_len = MIN(b2write, buf->b_fab_mrs);
4379 if (buf_write_bytes(&write_info) == FAIL)
4380 {
4381 end = 0;
4382 break;
4383 }
4384 b2write -= MIN(b2write, buf->b_fab_mrs);
4385 }
4386 write_info.bw_len = bufsize;
4387 nchars += len;
4388 s = buffer;
4389 len = 0;
4390 }
4391 #endif
4392 }
4393 if (len > 0 && end > 0)
4394 {
4395 write_info.bw_len = len;
4396 if (buf_write_bytes(&write_info) == FAIL)
4397 end = 0; /* write error */
4398 nchars += len;
4399 }
4400
4401 #if defined(UNIX) && defined(HAVE_FSYNC)
4402 /* On many journalling file systems there is a bug that causes both the
4403 * original and the backup file to be lost when halting the system right
4404 * after writing the file. That's because only the meta-data is
4405 * journalled. Syncing the file slows down the system, but assures it has
4406 * been written to disk and we don't lose it.
4407 * For a device do try the fsync() but don't complain if it does not work
4408 * (could be a pipe).
4409 * If the 'fsync' option is FALSE, don't fsync(). Useful for laptops. */
4410 if (p_fs && fsync(fd) != 0 && !device)
4411 {
4412 errmsg = (char_u *)_("E667: Fsync failed");
4413 end = 0;
4414 }
4415 #endif
4416
4417 #ifdef HAVE_SELINUX
4418 /* Probably need to set the security context. */
4419 if (!backup_copy)
4420 mch_copy_sec(backup, wfname);
4421 #endif
4422
4423 #ifdef UNIX
4424 /* When creating a new file, set its owner/group to that of the original
4425 * file. Get the new device and inode number. */
4426 if (backup != NULL && !backup_copy)
4427 {
4428 # ifdef HAVE_FCHOWN
4429 struct stat st;
4430
4431 /* don't change the owner when it's already OK, some systems remove
4432 * permission or ACL stuff */
4433 if (mch_stat((char *)wfname, &st) < 0
4434 || st.st_uid != st_old.st_uid
4435 || st.st_gid != st_old.st_gid)
4436 {
4437 ignored = fchown(fd, st_old.st_uid, st_old.st_gid);
4438 if (perm >= 0) /* set permission again, may have changed */
4439 (void)mch_setperm(wfname, perm);
4440 }
4441 # endif
4442 buf_setino(buf);
4443 }
4444 else if (!buf->b_dev_valid)
4445 /* Set the inode when creating a new file. */
4446 buf_setino(buf);
4447 #endif
4448
4449 if (close(fd) != 0)
4450 {
4451 errmsg = (char_u *)_("E512: Close failed");
4452 end = 0;
4453 }
4454
4455 #ifdef UNIX
4456 if (made_writable)
4457 perm &= ~0200; /* reset 'w' bit for security reasons */
4458 #endif
4459 if (perm >= 0) /* set perm. of new file same as old file */
4460 (void)mch_setperm(wfname, perm);
4461 #ifdef RISCOS
4462 if (!append && !filtering)
4463 /* Set the filetype after writing the file. */
4464 mch_set_filetype(wfname, buf->b_p_oft);
4465 #endif
4466 #ifdef HAVE_ACL
4467 /* Probably need to set the ACL before changing the user (can't set the
4468 * ACL on a file the user doesn't own). */
4469 if (!backup_copy)
4470 mch_set_acl(wfname, acl);
4471 #endif
4472
4473
4474 #if defined(FEAT_MBYTE) && defined(FEAT_EVAL)
4475 if (wfname != fname)
4476 {
4477 /*
4478 * The file was written to a temp file, now it needs to be converted
4479 * with 'charconvert' to (overwrite) the output file.
4480 */
4481 if (end != 0)
4482 {
4483 if (eval_charconvert(enc_utf8 ? (char_u *)"utf-8" : p_enc, fenc,
4484 wfname, fname) == FAIL)
4485 {
4486 write_info.bw_conv_error = TRUE;
4487 end = 0;
4488 }
4489 }
4490 mch_remove(wfname);
4491 vim_free(wfname);
4492 }
4493 #endif
4494
4495 if (end == 0)
4496 {
4497 if (errmsg == NULL)
4498 {
4499 #ifdef FEAT_MBYTE
4500 if (write_info.bw_conv_error)
4501 {
4502 if (write_info.bw_conv_error_lnum == 0)
4503 errmsg = (char_u *)_("E513: write error, conversion failed (make 'fenc' empty to override)");
4504 else
4505 {
4506 errmsg_allocated = TRUE;
4507 errmsg = alloc(300);
4508 vim_snprintf((char *)errmsg, 300, _("E513: write error, conversion failed in line %ld (make 'fenc' empty to override)"),
4509 (long)write_info.bw_conv_error_lnum);
4510 }
4511 }
4512 else
4513 #endif
4514 if (got_int)
4515 errmsg = (char_u *)_(e_interr);
4516 else
4517 errmsg = (char_u *)_("E514: write error (file system full?)");
4518 }
4519
4520 /*
4521 * If we have a backup file, try to put it in place of the new file,
4522 * because the new file is probably corrupt. This avoids losing the
4523 * original file when trying to make a backup when writing the file a
4524 * second time.
4525 * When "backup_copy" is set we need to copy the backup over the new
4526 * file. Otherwise rename the backup file.
4527 * If this is OK, don't give the extra warning message.
4528 */
4529 if (backup != NULL)
4530 {
4531 if (backup_copy)
4532 {
4533 /* This may take a while, if we were interrupted let the user
4534 * know we got the message. */
4535 if (got_int)
4536 {
4537 MSG(_(e_interr));
4538 out_flush();
4539 }
4540 if ((fd = mch_open((char *)backup, O_RDONLY | O_EXTRA, 0)) >= 0)
4541 {
4542 if ((write_info.bw_fd = mch_open((char *)fname,
4543 O_WRONLY | O_CREAT | O_TRUNC | O_EXTRA,
4544 perm & 0777)) >= 0)
4545 {
4546 /* copy the file. */
4547 write_info.bw_buf = smallbuf;
4548 #ifdef HAS_BW_FLAGS
4549 write_info.bw_flags = FIO_NOCONVERT;
4550 #endif
4551 while ((write_info.bw_len = vim_read(fd, smallbuf,
4552 SMBUFSIZE)) > 0)
4553 if (buf_write_bytes(&write_info) == FAIL)
4554 break;
4555
4556 if (close(write_info.bw_fd) >= 0
4557 && write_info.bw_len == 0)
4558 end = 1; /* success */
4559 }
4560 close(fd); /* ignore errors for closing read file */
4561 }
4562 }
4563 else
4564 {
4565 if (vim_rename(backup, fname) == 0)
4566 end = 1;
4567 }
4568 }
4569 goto fail;
4570 }
4571
4572 lnum -= start; /* compute number of written lines */
4573 --no_wait_return; /* may wait for return now */
4574
4575 #if !(defined(UNIX) || defined(VMS))
4576 fname = sfname; /* use shortname now, for the messages */
4577 #endif
4578 if (!filtering)
4579 {
4580 msg_add_fname(buf, fname); /* put fname in IObuff with quotes */
4581 c = FALSE;
4582 #ifdef FEAT_MBYTE
4583 if (write_info.bw_conv_error)
4584 {
4585 STRCAT(IObuff, _(" CONVERSION ERROR"));
4586 c = TRUE;
4587 if (write_info.bw_conv_error_lnum != 0)
4588 {
4589 size_t l = STRLEN(IObuff);
4590 vim_snprintf((char *)IObuff + l, IOSIZE - l, _(" in line %ld;"),
4591 (long)write_info.bw_conv_error_lnum);
4592 }
4593 }
4594 else if (notconverted)
4595 {
4596 STRCAT(IObuff, _("[NOT converted]"));
4597 c = TRUE;
4598 }
4599 else if (converted)
4600 {
4601 STRCAT(IObuff, _("[converted]"));
4602 c = TRUE;
4603 }
4604 #endif
4605 if (device)
4606 {
4607 STRCAT(IObuff, _("[Device]"));
4608 c = TRUE;
4609 }
4610 else if (newfile)
4611 {
4612 STRCAT(IObuff, shortmess(SHM_NEW) ? _("[New]") : _("[New File]"));
4613 c = TRUE;
4614 }
4615 if (no_eol)
4616 {
4617 msg_add_eol();
4618 c = TRUE;
4619 }
4620 /* may add [unix/dos/mac] */
4621 if (msg_add_fileformat(fileformat))
4622 c = TRUE;
4623 #ifdef FEAT_CRYPT
4624 if (wb_flags & FIO_ENCRYPTED)
4625 {
4626 STRCAT(IObuff, _("[crypted]"));
4627 c = TRUE;
4628 }
4629 #endif
4630 msg_add_lines(c, (long)lnum, nchars); /* add line/char count */
4631 if (!shortmess(SHM_WRITE))
4632 {
4633 if (append)
4634 STRCAT(IObuff, shortmess(SHM_WRI) ? _(" [a]") : _(" appended"));
4635 else
4636 STRCAT(IObuff, shortmess(SHM_WRI) ? _(" [w]") : _(" written"));
4637 }
4638
4639 set_keep_msg(msg_trunc_attr(IObuff, FALSE, 0), 0);
4640 }
4641
4642 /* When written everything correctly: reset 'modified'. Unless not
4643 * writing to the original file and '+' is not in 'cpoptions'. */
4644 if (reset_changed && whole && !append
4645 #ifdef FEAT_MBYTE
4646 && !write_info.bw_conv_error
4647 #endif
4648 && (overwriting || vim_strchr(p_cpo, CPO_PLUS) != NULL)
4649 )
4650 {
4651 unchanged(buf, TRUE);
4652 u_unchanged(buf);
4653 }
4654
4655 /*
4656 * If written to the current file, update the timestamp of the swap file
4657 * and reset the BF_WRITE_MASK flags. Also sets buf->b_mtime.
4658 */
4659 if (overwriting)
4660 {
4661 ml_timestamp(buf);
4662 if (append)
4663 buf->b_flags &= ~BF_NEW;
4664 else
4665 buf->b_flags &= ~BF_WRITE_MASK;
4666 }
4667
4668 /*
4669 * If we kept a backup until now, and we are in patch mode, then we make
4670 * the backup file our 'original' file.
4671 */
4672 if (*p_pm && dobackup)
4673 {
4674 char *org = (char *)buf_modname(
4675 #ifdef SHORT_FNAME
4676 TRUE,
4677 #else
4678 (buf->b_p_sn || buf->b_shortname),
4679 #endif
4680 fname, p_pm, FALSE);
4681
4682 if (backup != NULL)
4683 {
4684 struct stat st;
4685
4686 /*
4687 * If the original file does not exist yet
4688 * the current backup file becomes the original file
4689 */
4690 if (org == NULL)
4691 EMSG(_("E205: Patchmode: can't save original file"));
4692 else if (mch_stat(org, &st) < 0)
4693 {
4694 vim_rename(backup, (char_u *)org);
4695 vim_free(backup); /* don't delete the file */
4696 backup = NULL;
4697 #ifdef UNIX
4698 set_file_time((char_u *)org, st_old.st_atime, st_old.st_mtime);
4699 #endif
4700 }
4701 }
4702 /*
4703 * If there is no backup file, remember that a (new) file was
4704 * created.
4705 */
4706 else
4707 {
4708 int empty_fd;
4709
4710 if (org == NULL
4711 || (empty_fd = mch_open(org,
4712 O_CREAT | O_EXTRA | O_EXCL | O_NOFOLLOW,
4713 perm < 0 ? 0666 : (perm & 0777))) < 0)
4714 EMSG(_("E206: patchmode: can't touch empty original file"));
4715 else
4716 close(empty_fd);
4717 }
4718 if (org != NULL)
4719 {
4720 mch_setperm((char_u *)org, mch_getperm(fname) & 0777);
4721 vim_free(org);
4722 }
4723 }
4724
4725 /*
4726 * Remove the backup unless 'backup' option is set
4727 */
4728 if (!p_bk && backup != NULL && mch_remove(backup) != 0)
4729 EMSG(_("E207: Can't delete backup file"));
4730
4731 #ifdef FEAT_SUN_WORKSHOP
4732 if (usingSunWorkShop)
4733 workshop_file_saved((char *) ffname);
4734 #endif
4735
4736 goto nofail;
4737
4738 /*
4739 * Finish up. We get here either after failure or success.
4740 */
4741 fail:
4742 --no_wait_return; /* may wait for return now */
4743 nofail:
4744
4745 /* Done saving, we accept changed buffer warnings again */
4746 buf->b_saving = FALSE;
4747
4748 vim_free(backup);
4749 if (buffer != smallbuf)
4750 vim_free(buffer);
4751 #ifdef FEAT_MBYTE
4752 vim_free(fenc_tofree);
4753 vim_free(write_info.bw_conv_buf);
4754 # ifdef USE_ICONV
4755 if (write_info.bw_iconv_fd != (iconv_t)-1)
4756 {
4757 iconv_close(write_info.bw_iconv_fd);
4758 write_info.bw_iconv_fd = (iconv_t)-1;
4759 }
4760 # endif
4761 #endif
4762 #ifdef HAVE_ACL
4763 mch_free_acl(acl);
4764 #endif
4765
4766 if (errmsg != NULL)
4767 {
4768 int numlen = errnum != NULL ? (int)STRLEN(errnum) : 0;
4769
4770 attr = hl_attr(HLF_E); /* set highlight for error messages */
4771 msg_add_fname(buf,
4772 #ifndef UNIX
4773 sfname
4774 #else
4775 fname
4776 #endif
4777 ); /* put file name in IObuff with quotes */
4778 if (STRLEN(IObuff) + STRLEN(errmsg) + numlen >= IOSIZE)
4779 IObuff[IOSIZE - STRLEN(errmsg) - numlen - 1] = NUL;
4780 /* If the error message has the form "is ...", put the error number in
4781 * front of the file name. */
4782 if (errnum != NULL)
4783 {
4784 STRMOVE(IObuff + numlen, IObuff);
4785 mch_memmove(IObuff, errnum, (size_t)numlen);
4786 }
4787 STRCAT(IObuff, errmsg);
4788 emsg(IObuff);
4789 if (errmsg_allocated)
4790 vim_free(errmsg);
4791
4792 retval = FAIL;
4793 if (end == 0)
4794 {
4795 MSG_PUTS_ATTR(_("\nWARNING: Original file may be lost or damaged\n"),
4796 attr | MSG_HIST);
4797 MSG_PUTS_ATTR(_("don't quit the editor until the file is successfully written!"),
4798 attr | MSG_HIST);
4799
4800 /* Update the timestamp to avoid an "overwrite changed file"
4801 * prompt when writing again. */
4802 if (mch_stat((char *)fname, &st_old) >= 0)
4803 {
4804 buf_store_time(buf, &st_old, fname);
4805 buf->b_mtime_read = buf->b_mtime;
4806 }
4807 }
4808 }
4809 msg_scroll = msg_save;
4810
4811 #ifdef FEAT_AUTOCMD
4812 #ifdef FEAT_EVAL
4813 if (!should_abort(retval))
4814 #else
4815 if (!got_int)
4816 #endif
4817 {
4818 aco_save_T aco;
4819
4820 write_no_eol_lnum = 0; /* in case it was set by the previous read */
4821
4822 /*
4823 * Apply POST autocommands.
4824 * Careful: The autocommands may call buf_write() recursively!
4825 */
4826 aucmd_prepbuf(&aco, buf);
4827
4828 if (append)
4829 apply_autocmds_exarg(EVENT_FILEAPPENDPOST, fname, fname,
4830 FALSE, curbuf, eap);
4831 else if (filtering)
4832 apply_autocmds_exarg(EVENT_FILTERWRITEPOST, NULL, fname,
4833 FALSE, curbuf, eap);
4834 else if (reset_changed && whole)
4835 apply_autocmds_exarg(EVENT_BUFWRITEPOST, fname, fname,
4836 FALSE, curbuf, eap);
4837 else
4838 apply_autocmds_exarg(EVENT_FILEWRITEPOST, fname, fname,
4839 FALSE, curbuf, eap);
4840
4841 /* restore curwin/curbuf and a few other things */
4842 aucmd_restbuf(&aco);
4843
4844 #ifdef FEAT_EVAL
4845 if (aborting()) /* autocmds may abort script processing */
4846 retval = FALSE;
4847 #endif
4848 }
4849 #endif
4850
4851 got_int |= prev_got_int;
4852
4853 #ifdef MACOS_CLASSIC /* TODO: Is it need for MACOS_X? (Dany) */
4854 /* Update machine specific information. */
4855 mch_post_buffer_write(buf);
4856 #endif
4857 return retval;
4858 }
4859
4860 /*
4861 * Set the name of the current buffer. Use when the buffer doesn't have a
4862 * name and a ":r" or ":w" command with a file name is used.
4863 */
4864 static int
4865 set_rw_fname(fname, sfname)
4866 char_u *fname;
4867 char_u *sfname;
4868 {
4869 #ifdef FEAT_AUTOCMD
4870 buf_T *buf = curbuf;
4871
4872 /* It's like the unnamed buffer is deleted.... */
4873 if (curbuf->b_p_bl)
4874 apply_autocmds(EVENT_BUFDELETE, NULL, NULL, FALSE, curbuf);
4875 apply_autocmds(EVENT_BUFWIPEOUT, NULL, NULL, FALSE, curbuf);
4876 # ifdef FEAT_EVAL
4877 if (aborting()) /* autocmds may abort script processing */
4878 return FAIL;
4879 # endif
4880 if (curbuf != buf)
4881 {
4882 /* We are in another buffer now, don't do the renaming. */
4883 EMSG(_(e_auchangedbuf));
4884 return FAIL;
4885 }
4886 #endif
4887
4888 if (setfname(curbuf, fname, sfname, FALSE) == OK)
4889 curbuf->b_flags |= BF_NOTEDITED;
4890
4891 #ifdef FEAT_AUTOCMD
4892 /* ....and a new named one is created */
4893 apply_autocmds(EVENT_BUFNEW, NULL, NULL, FALSE, curbuf);
4894 if (curbuf->b_p_bl)
4895 apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, curbuf);
4896 # ifdef FEAT_EVAL
4897 if (aborting()) /* autocmds may abort script processing */
4898 return FAIL;
4899 # endif
4900
4901 /* Do filetype detection now if 'filetype' is empty. */
4902 if (*curbuf->b_p_ft == NUL)
4903 {
4904 if (au_has_group((char_u *)"filetypedetect"))
4905 (void)do_doautocmd((char_u *)"filetypedetect BufRead", FALSE);
4906 do_modelines(0);
4907 }
4908 #endif
4909
4910 return OK;
4911 }
4912
4913 /*
4914 * Put file name into IObuff with quotes.
4915 */
4916 void
4917 msg_add_fname(buf, fname)
4918 buf_T *buf;
4919 char_u *fname;
4920 {
4921 if (fname == NULL)
4922 fname = (char_u *)"-stdin-";
4923 home_replace(buf, fname, IObuff + 1, IOSIZE - 4, TRUE);
4924 IObuff[0] = '"';
4925 STRCAT(IObuff, "\" ");
4926 }
4927
4928 /*
4929 * Append message for text mode to IObuff.
4930 * Return TRUE if something appended.
4931 */
4932 static int
4933 msg_add_fileformat(eol_type)
4934 int eol_type;
4935 {
4936 #ifndef USE_CRNL
4937 if (eol_type == EOL_DOS)
4938 {
4939 STRCAT(IObuff, shortmess(SHM_TEXT) ? _("[dos]") : _("[dos format]"));
4940 return TRUE;
4941 }
4942 #endif
4943 #ifndef USE_CR
4944 if (eol_type == EOL_MAC)
4945 {
4946 STRCAT(IObuff, shortmess(SHM_TEXT) ? _("[mac]") : _("[mac format]"));
4947 return TRUE;
4948 }
4949 #endif
4950 #if defined(USE_CRNL) || defined(USE_CR)
4951 if (eol_type == EOL_UNIX)
4952 {
4953 STRCAT(IObuff, shortmess(SHM_TEXT) ? _("[unix]") : _("[unix format]"));
4954 return TRUE;
4955 }
4956 #endif
4957 return FALSE;
4958 }
4959
4960 /*
4961 * Append line and character count to IObuff.
4962 */
4963 void
4964 msg_add_lines(insert_space, lnum, nchars)
4965 int insert_space;
4966 long lnum;
4967 long nchars;
4968 {
4969 char_u *p;
4970
4971 p = IObuff + STRLEN(IObuff);
4972
4973 if (insert_space)
4974 *p++ = ' ';
4975 if (shortmess(SHM_LINES))
4976 sprintf((char *)p, "%ldL, %ldC", lnum, nchars);
4977 else
4978 {
4979 if (lnum == 1)
4980 STRCPY(p, _("1 line, "));
4981 else
4982 sprintf((char *)p, _("%ld lines, "), lnum);
4983 p += STRLEN(p);
4984 if (nchars == 1)
4985 STRCPY(p, _("1 character"));
4986 else
4987 sprintf((char *)p, _("%ld characters"), nchars);
4988 }
4989 }
4990
4991 /*
4992 * Append message for missing line separator to IObuff.
4993 */
4994 static void
4995 msg_add_eol()
4996 {
4997 STRCAT(IObuff, shortmess(SHM_LAST) ? _("[noeol]") : _("[Incomplete last line]"));
4998 }
4999
5000 /*
5001 * Check modification time of file, before writing to it.
5002 * The size isn't checked, because using a tool like "gzip" takes care of
5003 * using the same timestamp but can't set the size.
5004 */
5005 static int
5006 check_mtime(buf, st)
5007 buf_T *buf;
5008 struct stat *st;
5009 {
5010 if (buf->b_mtime_read != 0
5011 && time_differs((long)st->st_mtime, buf->b_mtime_read))
5012 {
5013 msg_scroll = TRUE; /* don't overwrite messages here */
5014 msg_silent = 0; /* must give this prompt */
5015 /* don't use emsg() here, don't want to flush the buffers */
5016 MSG_ATTR(_("WARNING: The file has been changed since reading it!!!"),
5017 hl_attr(HLF_E));
5018 if (ask_yesno((char_u *)_("Do you really want to write to it"),
5019 TRUE) == 'n')
5020 return FAIL;
5021 msg_scroll = FALSE; /* always overwrite the file message now */
5022 }
5023 return OK;
5024 }
5025
5026 static int
5027 time_differs(t1, t2)
5028 long t1, t2;
5029 {
5030 #if defined(__linux__) || defined(MSDOS) || defined(MSWIN)
5031 /* On a FAT filesystem, esp. under Linux, there are only 5 bits to store
5032 * the seconds. Since the roundoff is done when flushing the inode, the
5033 * time may change unexpectedly by one second!!! */
5034 return (t1 - t2 > 1 || t2 - t1 > 1);
5035 #else
5036 return (t1 != t2);
5037 #endif
5038 }
5039
5040 /*
5041 * Call write() to write a number of bytes to the file.
5042 * Also handles encryption and 'encoding' conversion.
5043 *
5044 * Return FAIL for failure, OK otherwise.
5045 */
5046 static int
5047 buf_write_bytes(ip)
5048 struct bw_info *ip;
5049 {
5050 int wlen;
5051 char_u *buf = ip->bw_buf; /* data to write */
5052 int len = ip->bw_len; /* length of data */
5053 #ifdef HAS_BW_FLAGS
5054 int flags = ip->bw_flags; /* extra flags */
5055 #endif
5056
5057 #ifdef FEAT_MBYTE
5058 /*
5059 * Skip conversion when writing the crypt magic number or the BOM.
5060 */
5061 if (!(flags & FIO_NOCONVERT))
5062 {
5063 char_u *p;
5064 unsigned c;
5065 int n;
5066
5067 if (flags & FIO_UTF8)
5068 {
5069 /*
5070 * Convert latin1 in the buffer to UTF-8 in the file.
5071 */
5072 p = ip->bw_conv_buf; /* translate to buffer */
5073 for (wlen = 0; wlen < len; ++wlen)
5074 p += utf_char2bytes(buf[wlen], p);
5075 buf = ip->bw_conv_buf;
5076 len = (int)(p - ip->bw_conv_buf);
5077 }
5078 else if (flags & (FIO_UCS4 | FIO_UTF16 | FIO_UCS2 | FIO_LATIN1))
5079 {
5080 /*
5081 * Convert UTF-8 bytes in the buffer to UCS-2, UCS-4, UTF-16 or
5082 * Latin1 chars in the file.
5083 */
5084 if (flags & FIO_LATIN1)
5085 p = buf; /* translate in-place (can only get shorter) */
5086 else
5087 p = ip->bw_conv_buf; /* translate to buffer */
5088 for (wlen = 0; wlen < len; wlen += n)
5089 {
5090 if (wlen == 0 && ip->bw_restlen != 0)
5091 {
5092 int l;
5093
5094 /* Use remainder of previous call. Append the start of
5095 * buf[] to get a full sequence. Might still be too
5096 * short! */
5097 l = CONV_RESTLEN - ip->bw_restlen;
5098 if (l > len)
5099 l = len;
5100 mch_memmove(ip->bw_rest + ip->bw_restlen, buf, (size_t)l);
5101 n = utf_ptr2len_len(ip->bw_rest, ip->bw_restlen + l);
5102 if (n > ip->bw_restlen + len)
5103 {
5104 /* We have an incomplete byte sequence at the end to
5105 * be written. We can't convert it without the
5106 * remaining bytes. Keep them for the next call. */
5107 if (ip->bw_restlen + len > CONV_RESTLEN)
5108 return FAIL;
5109 ip->bw_restlen += len;
5110 break;
5111 }
5112 if (n > 1)
5113 c = utf_ptr2char(ip->bw_rest);
5114 else
5115 c = ip->bw_rest[0];
5116 if (n >= ip->bw_restlen)
5117 {
5118 n -= ip->bw_restlen;
5119 ip->bw_restlen = 0;
5120 }
5121 else
5122 {
5123 ip->bw_restlen -= n;
5124 mch_memmove(ip->bw_rest, ip->bw_rest + n,
5125 (size_t)ip->bw_restlen);
5126 n = 0;
5127 }
5128 }
5129 else
5130 {
5131 n = utf_ptr2len_len(buf + wlen, len - wlen);
5132 if (n > len - wlen)
5133 {
5134 /* We have an incomplete byte sequence at the end to
5135 * be written. We can't convert it without the
5136 * remaining bytes. Keep them for the next call. */
5137 if (len - wlen > CONV_RESTLEN)
5138 return FAIL;
5139 ip->bw_restlen = len - wlen;
5140 mch_memmove(ip->bw_rest, buf + wlen,
5141 (size_t)ip->bw_restlen);
5142 break;
5143 }
5144 if (n > 1)
5145 c = utf_ptr2char(buf + wlen);
5146 else
5147 c = buf[wlen];
5148 }
5149
5150 if (ucs2bytes(c, &p, flags) && !ip->bw_conv_error)
5151 {
5152 ip->bw_conv_error = TRUE;
5153 ip->bw_conv_error_lnum = ip->bw_start_lnum;
5154 }
5155 if (c == NL)
5156 ++ip->bw_start_lnum;
5157 }
5158 if (flags & FIO_LATIN1)
5159 len = (int)(p - buf);
5160 else
5161 {
5162 buf = ip->bw_conv_buf;
5163 len = (int)(p - ip->bw_conv_buf);
5164 }
5165 }
5166
5167 # ifdef WIN3264
5168 else if (flags & FIO_CODEPAGE)
5169 {
5170 /*
5171 * Convert UTF-8 or codepage to UCS-2 and then to MS-Windows
5172 * codepage.
5173 */
5174 char_u *from;
5175 size_t fromlen;
5176 char_u *to;
5177 int u8c;
5178 BOOL bad = FALSE;
5179 int needed;
5180
5181 if (ip->bw_restlen > 0)
5182 {
5183 /* Need to concatenate the remainder of the previous call and
5184 * the bytes of the current call. Use the end of the
5185 * conversion buffer for this. */
5186 fromlen = len + ip->bw_restlen;
5187 from = ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
5188 mch_memmove(from, ip->bw_rest, (size_t)ip->bw_restlen);
5189 mch_memmove(from + ip->bw_restlen, buf, (size_t)len);
5190 }
5191 else
5192 {
5193 from = buf;
5194 fromlen = len;
5195 }
5196
5197 to = ip->bw_conv_buf;
5198 if (enc_utf8)
5199 {
5200 /* Convert from UTF-8 to UCS-2, to the start of the buffer.
5201 * The buffer has been allocated to be big enough. */
5202 while (fromlen > 0)
5203 {
5204 n = (int)utf_ptr2len_len(from, (int)fromlen);
5205 if (n > (int)fromlen) /* incomplete byte sequence */
5206 break;
5207 u8c = utf_ptr2char(from);
5208 *to++ = (u8c & 0xff);
5209 *to++ = (u8c >> 8);
5210 fromlen -= n;
5211 from += n;
5212 }
5213
5214 /* Copy remainder to ip->bw_rest[] to be used for the next
5215 * call. */
5216 if (fromlen > CONV_RESTLEN)
5217 {
5218 /* weird overlong sequence */
5219 ip->bw_conv_error = TRUE;
5220 return FAIL;
5221 }
5222 mch_memmove(ip->bw_rest, from, fromlen);
5223 ip->bw_restlen = (int)fromlen;
5224 }
5225 else
5226 {
5227 /* Convert from enc_codepage to UCS-2, to the start of the
5228 * buffer. The buffer has been allocated to be big enough. */
5229 ip->bw_restlen = 0;
5230 needed = MultiByteToWideChar(enc_codepage,
5231 MB_ERR_INVALID_CHARS, (LPCSTR)from, (int)fromlen,
5232 NULL, 0);
5233 if (needed == 0)
5234 {
5235 /* When conversion fails there may be a trailing byte. */
5236 needed = MultiByteToWideChar(enc_codepage,
5237 MB_ERR_INVALID_CHARS, (LPCSTR)from, (int)fromlen - 1,
5238 NULL, 0);
5239 if (needed == 0)
5240 {
5241 /* Conversion doesn't work. */
5242 ip->bw_conv_error = TRUE;
5243 return FAIL;
5244 }
5245 /* Save the trailing byte for the next call. */
5246 ip->bw_rest[0] = from[fromlen - 1];
5247 ip->bw_restlen = 1;
5248 }
5249 needed = MultiByteToWideChar(enc_codepage, MB_ERR_INVALID_CHARS,
5250 (LPCSTR)from, (int)(fromlen - ip->bw_restlen),
5251 (LPWSTR)to, needed);
5252 if (needed == 0)
5253 {
5254 /* Safety check: Conversion doesn't work. */
5255 ip->bw_conv_error = TRUE;
5256 return FAIL;
5257 }
5258 to += needed * 2;
5259 }
5260
5261 fromlen = to - ip->bw_conv_buf;
5262 buf = to;
5263 # ifdef CP_UTF8 /* VC 4.1 doesn't define CP_UTF8 */
5264 if (FIO_GET_CP(flags) == CP_UTF8)
5265 {
5266 /* Convert from UCS-2 to UTF-8, using the remainder of the
5267 * conversion buffer. Fails when out of space. */
5268 for (from = ip->bw_conv_buf; fromlen > 1; fromlen -= 2)
5269 {
5270 u8c = *from++;
5271 u8c += (*from++ << 8);
5272 to += utf_char2bytes(u8c, to);
5273 if (to + 6 >= ip->bw_conv_buf + ip->bw_conv_buflen)
5274 {
5275 ip->bw_conv_error = TRUE;
5276 return FAIL;
5277 }
5278 }
5279 len = (int)(to - buf);
5280 }
5281 else
5282 #endif
5283 {
5284 /* Convert from UCS-2 to the codepage, using the remainder of
5285 * the conversion buffer. If the conversion uses the default
5286 * character "0", the data doesn't fit in this encoding, so
5287 * fail. */
5288 len = WideCharToMultiByte(FIO_GET_CP(flags), 0,
5289 (LPCWSTR)ip->bw_conv_buf, (int)fromlen / sizeof(WCHAR),
5290 (LPSTR)to, (int)(ip->bw_conv_buflen - fromlen), 0,
5291 &bad);
5292 if (bad)
5293 {
5294 ip->bw_conv_error = TRUE;
5295 return FAIL;
5296 }
5297 }
5298 }
5299 # endif
5300
5301 # ifdef MACOS_CONVERT
5302 else if (flags & FIO_MACROMAN)
5303 {
5304 /*
5305 * Convert UTF-8 or latin1 to Apple MacRoman.
5306 */
5307 char_u *from;
5308 size_t fromlen;
5309
5310 if (ip->bw_restlen > 0)
5311 {
5312 /* Need to concatenate the remainder of the previous call and
5313 * the bytes of the current call. Use the end of the
5314 * conversion buffer for this. */
5315 fromlen = len + ip->bw_restlen;
5316 from = ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
5317 mch_memmove(from, ip->bw_rest, (size_t)ip->bw_restlen);
5318 mch_memmove(from + ip->bw_restlen, buf, (size_t)len);
5319 }
5320 else
5321 {
5322 from = buf;
5323 fromlen = len;
5324 }
5325
5326 if (enc2macroman(from, fromlen,
5327 ip->bw_conv_buf, &len, ip->bw_conv_buflen,
5328 ip->bw_rest, &ip->bw_restlen) == FAIL)
5329 {
5330 ip->bw_conv_error = TRUE;
5331 return FAIL;
5332 }
5333 buf = ip->bw_conv_buf;
5334 }
5335 # endif
5336
5337 # ifdef USE_ICONV
5338 if (ip->bw_iconv_fd != (iconv_t)-1)
5339 {
5340 const char *from;
5341 size_t fromlen;
5342 char *to;
5343 size_t tolen;
5344
5345 /* Convert with iconv(). */
5346 if (ip->bw_restlen > 0)
5347 {
5348 char *fp;
5349
5350 /* Need to concatenate the remainder of the previous call and
5351 * the bytes of the current call. Use the end of the
5352 * conversion buffer for this. */
5353 fromlen = len + ip->bw_restlen;
5354 fp = (char *)ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
5355 mch_memmove(fp, ip->bw_rest, (size_t)ip->bw_restlen);
5356 mch_memmove(fp + ip->bw_restlen, buf, (size_t)len);
5357 from = fp;
5358 tolen = ip->bw_conv_buflen - fromlen;
5359 }
5360 else
5361 {
5362 from = (const char *)buf;
5363 fromlen = len;
5364 tolen = ip->bw_conv_buflen;
5365 }
5366 to = (char *)ip->bw_conv_buf;
5367
5368 if (ip->bw_first)
5369 {
5370 size_t save_len = tolen;
5371
5372 /* output the initial shift state sequence */
5373 (void)iconv(ip->bw_iconv_fd, NULL, NULL, &to, &tolen);
5374
5375 /* There is a bug in iconv() on Linux (which appears to be
5376 * wide-spread) which sets "to" to NULL and messes up "tolen".
5377 */
5378 if (to == NULL)
5379 {
5380 to = (char *)ip->bw_conv_buf;
5381 tolen = save_len;
5382 }
5383 ip->bw_first = FALSE;
5384 }
5385
5386 /*
5387 * If iconv() has an error or there is not enough room, fail.
5388 */
5389 if ((iconv(ip->bw_iconv_fd, (void *)&from, &fromlen, &to, &tolen)
5390 == (size_t)-1 && ICONV_ERRNO != ICONV_EINVAL)
5391 || fromlen > CONV_RESTLEN)
5392 {
5393 ip->bw_conv_error = TRUE;
5394 return FAIL;
5395 }
5396
5397 /* copy remainder to ip->bw_rest[] to be used for the next call. */
5398 if (fromlen > 0)
5399 mch_memmove(ip->bw_rest, (void *)from, fromlen);
5400 ip->bw_restlen = (int)fromlen;
5401
5402 buf = ip->bw_conv_buf;
5403 len = (int)((char_u *)to - ip->bw_conv_buf);
5404 }
5405 # endif
5406 }
5407 #endif /* FEAT_MBYTE */
5408
5409 #ifdef FEAT_CRYPT
5410 if (flags & FIO_ENCRYPTED) /* encrypt the data */
5411 {
5412 int ztemp, t, i;
5413
5414 for (i = 0; i < len; i++)
5415 {
5416 ztemp = buf[i];
5417 buf[i] = ZENCODE(ztemp, t);
5418 }
5419 }
5420 #endif
5421
5422 /* Repeat the write(), it may be interrupted by a signal. */
5423 while (len > 0)
5424 {
5425 wlen = vim_write(ip->bw_fd, buf, len);
5426 if (wlen <= 0) /* error! */
5427 return FAIL;
5428 len -= wlen;
5429 buf += wlen;
5430 }
5431 return OK;
5432 }
5433
5434 #ifdef FEAT_MBYTE
5435 /*
5436 * Convert a Unicode character to bytes.
5437 * Return TRUE for an error, FALSE when it's OK.
5438 */
5439 static int
5440 ucs2bytes(c, pp, flags)
5441 unsigned c; /* in: character */
5442 char_u **pp; /* in/out: pointer to result */
5443 int flags; /* FIO_ flags */
5444 {
5445 char_u *p = *pp;
5446 int error = FALSE;
5447 int cc;
5448
5449
5450 if (flags & FIO_UCS4)
5451 {
5452 if (flags & FIO_ENDIAN_L)
5453 {
5454 *p++ = c;
5455 *p++ = (c >> 8);
5456 *p++ = (c >> 16);
5457 *p++ = (c >> 24);
5458 }
5459 else
5460 {
5461 *p++ = (c >> 24);
5462 *p++ = (c >> 16);
5463 *p++ = (c >> 8);
5464 *p++ = c;
5465 }
5466 }
5467 else if (flags & (FIO_UCS2 | FIO_UTF16))
5468 {
5469 if (c >= 0x10000)
5470 {
5471 if (flags & FIO_UTF16)
5472 {
5473 /* Make two words, ten bits of the character in each. First
5474 * word is 0xd800 - 0xdbff, second one 0xdc00 - 0xdfff */
5475 c -= 0x10000;
5476 if (c >= 0x100000)
5477 error = TRUE;
5478 cc = ((c >> 10) & 0x3ff) + 0xd800;
5479 if (flags & FIO_ENDIAN_L)
5480 {
5481 *p++ = cc;
5482 *p++ = ((unsigned)cc >> 8);
5483 }
5484 else
5485 {
5486 *p++ = ((unsigned)cc >> 8);
5487 *p++ = cc;
5488 }
5489 c = (c & 0x3ff) + 0xdc00;
5490 }
5491 else
5492 error = TRUE;
5493 }
5494 if (flags & FIO_ENDIAN_L)
5495 {
5496 *p++ = c;
5497 *p++ = (c >> 8);
5498 }
5499 else
5500 {
5501 *p++ = (c >> 8);
5502 *p++ = c;
5503 }
5504 }
5505 else /* Latin1 */
5506 {
5507 if (c >= 0x100)
5508 {
5509 error = TRUE;
5510 *p++ = 0xBF;
5511 }
5512 else
5513 *p++ = c;
5514 }
5515
5516 *pp = p;
5517 return error;
5518 }
5519
5520 /*
5521 * Return TRUE if file encoding "fenc" requires conversion from or to
5522 * 'encoding'.
5523 */
5524 static int
5525 need_conversion(fenc)
5526 char_u *fenc;
5527 {
5528 int same_encoding;
5529 int enc_flags;
5530 int fenc_flags;
5531
5532 if (*fenc == NUL || STRCMP(p_enc, fenc) == 0)
5533 same_encoding = TRUE;
5534 else
5535 {
5536 /* Ignore difference between "ansi" and "latin1", "ucs-4" and
5537 * "ucs-4be", etc. */
5538 enc_flags = get_fio_flags(p_enc);
5539 fenc_flags = get_fio_flags(fenc);
5540 same_encoding = (enc_flags != 0 && fenc_flags == enc_flags);
5541 }
5542 if (same_encoding)
5543 {
5544 /* Specified encoding matches with 'encoding'. This requires
5545 * conversion when 'encoding' is Unicode but not UTF-8. */
5546 return enc_unicode != 0;
5547 }
5548
5549 /* Encodings differ. However, conversion is not needed when 'enc' is any
5550 * Unicode encoding and the file is UTF-8. */
5551 return !(enc_utf8 && fenc_flags == FIO_UTF8);
5552 }
5553
5554 /*
5555 * Check "ptr" for a unicode encoding and return the FIO_ flags needed for the
5556 * internal conversion.
5557 * if "ptr" is an empty string, use 'encoding'.
5558 */
5559 static int
5560 get_fio_flags(ptr)
5561 char_u *ptr;
5562 {
5563 int prop;
5564
5565 if (*ptr == NUL)
5566 ptr = p_enc;
5567
5568 prop = enc_canon_props(ptr);
5569 if (prop & ENC_UNICODE)
5570 {
5571 if (prop & ENC_2BYTE)
5572 {
5573 if (prop & ENC_ENDIAN_L)
5574 return FIO_UCS2 | FIO_ENDIAN_L;
5575 return FIO_UCS2;
5576 }
5577 if (prop & ENC_4BYTE)
5578 {
5579 if (prop & ENC_ENDIAN_L)
5580 return FIO_UCS4 | FIO_ENDIAN_L;
5581 return FIO_UCS4;
5582 }
5583 if (prop & ENC_2WORD)
5584 {
5585 if (prop & ENC_ENDIAN_L)
5586 return FIO_UTF16 | FIO_ENDIAN_L;
5587 return FIO_UTF16;
5588 }
5589 return FIO_UTF8;
5590 }
5591 if (prop & ENC_LATIN1)
5592 return FIO_LATIN1;
5593 /* must be ENC_DBCS, requires iconv() */
5594 return 0;
5595 }
5596
5597 #ifdef WIN3264
5598 /*
5599 * Check "ptr" for a MS-Windows codepage name and return the FIO_ flags needed
5600 * for the conversion MS-Windows can do for us. Also accept "utf-8".
5601 * Used for conversion between 'encoding' and 'fileencoding'.
5602 */
5603 static int
5604 get_win_fio_flags(ptr)
5605 char_u *ptr;
5606 {
5607 int cp;
5608
5609 /* Cannot do this when 'encoding' is not utf-8 and not a codepage. */
5610 if (!enc_utf8 && enc_codepage <= 0)
5611 return 0;
5612
5613 cp = encname2codepage(ptr);
5614 if (cp == 0)
5615 {
5616 # ifdef CP_UTF8 /* VC 4.1 doesn't define CP_UTF8 */
5617 if (STRCMP(ptr, "utf-8") == 0)
5618 cp = CP_UTF8;
5619 else
5620 # endif
5621 return 0;
5622 }
5623 return FIO_PUT_CP(cp) | FIO_CODEPAGE;
5624 }
5625 #endif
5626
5627 #ifdef MACOS_X
5628 /*
5629 * Check "ptr" for a Carbon supported encoding and return the FIO_ flags
5630 * needed for the internal conversion to/from utf-8 or latin1.
5631 */
5632 static int
5633 get_mac_fio_flags(ptr)
5634 char_u *ptr;
5635 {
5636 if ((enc_utf8 || STRCMP(p_enc, "latin1") == 0)
5637 && (enc_canon_props(ptr) & ENC_MACROMAN))
5638 return FIO_MACROMAN;
5639 return 0;
5640 }
5641 #endif
5642
5643 /*
5644 * Check for a Unicode BOM (Byte Order Mark) at the start of p[size].
5645 * "size" must be at least 2.
5646 * Return the name of the encoding and set "*lenp" to the length.
5647 * Returns NULL when no BOM found.
5648 */
5649 static char_u *
5650 check_for_bom(p, size, lenp, flags)
5651 char_u *p;
5652 long size;
5653 int *lenp;
5654 int flags;
5655 {
5656 char *name = NULL;
5657 int len = 2;
5658
5659 if (p[0] == 0xef && p[1] == 0xbb && size >= 3 && p[2] == 0xbf
5660 && (flags == FIO_ALL || flags == FIO_UTF8 || flags == 0))
5661 {
5662 name = "utf-8"; /* EF BB BF */
5663 len = 3;
5664 }
5665 else if (p[0] == 0xff && p[1] == 0xfe)
5666 {
5667 if (size >= 4 && p[2] == 0 && p[3] == 0
5668 && (flags == FIO_ALL || flags == (FIO_UCS4 | FIO_ENDIAN_L)))
5669 {
5670 name = "ucs-4le"; /* FF FE 00 00 */
5671 len = 4;
5672 }
5673 else if (flags == (FIO_UCS2 | FIO_ENDIAN_L))
5674 name = "ucs-2le"; /* FF FE */
5675 else if (flags == FIO_ALL || flags == (FIO_UTF16 | FIO_ENDIAN_L))
5676 /* utf-16le is preferred, it also works for ucs-2le text */
5677 name = "utf-16le"; /* FF FE */
5678 }
5679 else if (p[0] == 0xfe && p[1] == 0xff
5680 && (flags == FIO_ALL || flags == FIO_UCS2 || flags == FIO_UTF16))
5681 {
5682 /* Default to utf-16, it works also for ucs-2 text. */
5683 if (flags == FIO_UCS2)
5684 name = "ucs-2"; /* FE FF */
5685 else
5686 name = "utf-16"; /* FE FF */
5687 }
5688 else if (size >= 4 && p[0] == 0 && p[1] == 0 && p[2] == 0xfe
5689 && p[3] == 0xff && (flags == FIO_ALL || flags == FIO_UCS4))
5690 {
5691 name = "ucs-4"; /* 00 00 FE FF */
5692 len = 4;
5693 }
5694
5695 *lenp = len;
5696 return (char_u *)name;
5697 }
5698
5699 /*
5700 * Generate a BOM in "buf[4]" for encoding "name".
5701 * Return the length of the BOM (zero when no BOM).
5702 */
5703 static int
5704 make_bom(buf, name)
5705 char_u *buf;
5706 char_u *name;
5707 {
5708 int flags;
5709 char_u *p;
5710
5711 flags = get_fio_flags(name);
5712
5713 /* Can't put a BOM in a non-Unicode file. */
5714 if (flags == FIO_LATIN1 || flags == 0)
5715 return 0;
5716
5717 if (flags == FIO_UTF8) /* UTF-8 */
5718 {
5719 buf[0] = 0xef;
5720 buf[1] = 0xbb;
5721 buf[2] = 0xbf;
5722 return 3;
5723 }
5724 p = buf;
5725 (void)ucs2bytes(0xfeff, &p, flags);
5726 return (int)(p - buf);
5727 }
5728 #endif
5729
5730 #if defined(FEAT_VIMINFO) || defined(FEAT_BROWSE) || \
5731 defined(FEAT_QUICKFIX) || defined(FEAT_AUTOCMD) || defined(PROTO)
5732 /*
5733 * Try to find a shortname by comparing the fullname with the current
5734 * directory.
5735 * Returns "full_path" or pointer into "full_path" if shortened.
5736 */
5737 char_u *
5738 shorten_fname1(full_path)
5739 char_u *full_path;
5740 {
5741 char_u dirname[MAXPATHL];
5742 char_u *p = full_path;
5743
5744 if (mch_dirname(dirname, MAXPATHL) == OK)
5745 {
5746 p = shorten_fname(full_path, dirname);
5747 if (p == NULL || *p == NUL)
5748 p = full_path;
5749 }
5750 return p;
5751 }
5752 #endif
5753
5754 /*
5755 * Try to find a shortname by comparing the fullname with the current
5756 * directory.
5757 * Returns NULL if not shorter name possible, pointer into "full_path"
5758 * otherwise.
5759 */
5760 char_u *
5761 shorten_fname(full_path, dir_name)
5762 char_u *full_path;
5763 char_u *dir_name;
5764 {
5765 int len;
5766 char_u *p;
5767
5768 if (full_path == NULL)
5769 return NULL;
5770 len = (int)STRLEN(dir_name);
5771 if (fnamencmp(dir_name, full_path, len) == 0)
5772 {
5773 p = full_path + len;
5774 #if defined(MSDOS) || defined(MSWIN) || defined(OS2)
5775 /*
5776 * MSDOS: when a file is in the root directory, dir_name will end in a
5777 * slash, since C: by itself does not define a specific dir. In this
5778 * case p may already be correct. <negri>
5779 */
5780 if (!((len > 2) && (*(p - 2) == ':')))
5781 #endif
5782 {
5783 if (vim_ispathsep(*p))
5784 ++p;
5785 #ifndef VMS /* the path separator is always part of the path */
5786 else
5787 p = NULL;
5788 #endif
5789 }
5790 }
5791 #if defined(MSDOS) || defined(MSWIN) || defined(OS2)
5792 /*
5793 * When using a file in the current drive, remove the drive name:
5794 * "A:\dir\file" -> "\dir\file". This helps when moving a session file on
5795 * a floppy from "A:\dir" to "B:\dir".
5796 */
5797 else if (len > 3
5798 && TOUPPER_LOC(full_path[0]) == TOUPPER_LOC(dir_name[0])
5799 && full_path[1] == ':'
5800 && vim_ispathsep(full_path[2]))
5801 p = full_path + 2;
5802 #endif
5803 else
5804 p = NULL;
5805 return p;
5806 }
5807
5808 /*
5809 * Shorten filenames for all buffers.
5810 * When "force" is TRUE: Use full path from now on for files currently being
5811 * edited, both for file name and swap file name. Try to shorten the file
5812 * names a bit, if safe to do so.
5813 * When "force" is FALSE: Only try to shorten absolute file names.
5814 * For buffers that have buftype "nofile" or "scratch": never change the file
5815 * name.
5816 */
5817 void
5818 shorten_fnames(force)
5819 int force;
5820 {
5821 char_u dirname[MAXPATHL];
5822 buf_T *buf;
5823 char_u *p;
5824
5825 mch_dirname(dirname, MAXPATHL);
5826 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
5827 {
5828 if (buf->b_fname != NULL
5829 #ifdef FEAT_QUICKFIX
5830 && !bt_nofile(buf)
5831 #endif
5832 && !path_with_url(buf->b_fname)
5833 && (force
5834 || buf->b_sfname == NULL
5835 || mch_isFullName(buf->b_sfname)))
5836 {
5837 vim_free(buf->b_sfname);
5838 buf->b_sfname = NULL;
5839 p = shorten_fname(buf->b_ffname, dirname);
5840 if (p != NULL)
5841 {
5842 buf->b_sfname = vim_strsave(p);
5843 buf->b_fname = buf->b_sfname;
5844 }
5845 if (p == NULL || buf->b_fname == NULL)
5846 buf->b_fname = buf->b_ffname;
5847 }
5848
5849 /* Always make the swap file name a full path, a "nofile" buffer may
5850 * also have a swap file. */
5851 mf_fullname(buf->b_ml.ml_mfp);
5852 }
5853 #ifdef FEAT_WINDOWS
5854 status_redraw_all();
5855 redraw_tabline = TRUE;
5856 #endif
5857 }
5858
5859 #if (defined(FEAT_DND) && defined(FEAT_GUI_GTK)) \
5860 || defined(FEAT_GUI_MSWIN) \
5861 || defined(FEAT_GUI_MAC) \
5862 || defined(PROTO)
5863 /*
5864 * Shorten all filenames in "fnames[count]" by current directory.
5865 */
5866 void
5867 shorten_filenames(fnames, count)
5868 char_u **fnames;
5869 int count;
5870 {
5871 int i;
5872 char_u dirname[MAXPATHL];
5873 char_u *p;
5874
5875 if (fnames == NULL || count < 1)
5876 return;
5877 mch_dirname(dirname, sizeof(dirname));
5878 for (i = 0; i < count; ++i)
5879 {
5880 if ((p = shorten_fname(fnames[i], dirname)) != NULL)
5881 {
5882 /* shorten_fname() returns pointer in given "fnames[i]". If free
5883 * "fnames[i]" first, "p" becomes invalid. So we need to copy
5884 * "p" first then free fnames[i]. */
5885 p = vim_strsave(p);
5886 vim_free(fnames[i]);
5887 fnames[i] = p;
5888 }
5889 }
5890 }
5891 #endif
5892
5893 /*
5894 * add extension to file name - change path/fo.o.h to path/fo.o.h.ext or
5895 * fo_o_h.ext for MSDOS or when shortname option set.
5896 *
5897 * Assumed that fname is a valid name found in the filesystem we assure that
5898 * the return value is a different name and ends in 'ext'.
5899 * "ext" MUST be at most 4 characters long if it starts with a dot, 3
5900 * characters otherwise.
5901 * Space for the returned name is allocated, must be freed later.
5902 * Returns NULL when out of memory.
5903 */
5904 char_u *
5905 modname(fname, ext, prepend_dot)
5906 char_u *fname, *ext;
5907 int prepend_dot; /* may prepend a '.' to file name */
5908 {
5909 return buf_modname(
5910 #ifdef SHORT_FNAME
5911 TRUE,
5912 #else
5913 (curbuf->b_p_sn || curbuf->b_shortname),
5914 #endif
5915 fname, ext, prepend_dot);
5916 }
5917
5918 char_u *
5919 buf_modname(shortname, fname, ext, prepend_dot)
5920 int shortname; /* use 8.3 file name */
5921 char_u *fname, *ext;
5922 int prepend_dot; /* may prepend a '.' to file name */
5923 {
5924 char_u *retval;
5925 char_u *s;
5926 char_u *e;
5927 char_u *ptr;
5928 int fnamelen, extlen;
5929
5930 extlen = (int)STRLEN(ext);
5931
5932 /*
5933 * If there is no file name we must get the name of the current directory
5934 * (we need the full path in case :cd is used).
5935 */
5936 if (fname == NULL || *fname == NUL)
5937 {
5938 retval = alloc((unsigned)(MAXPATHL + extlen + 3));
5939 if (retval == NULL)
5940 return NULL;
5941 if (mch_dirname(retval, MAXPATHL) == FAIL ||
5942 (fnamelen = (int)STRLEN(retval)) == 0)
5943 {
5944 vim_free(retval);
5945 return NULL;
5946 }
5947 if (!after_pathsep(retval, retval + fnamelen))
5948 {
5949 retval[fnamelen++] = PATHSEP;
5950 retval[fnamelen] = NUL;
5951 }
5952 #ifndef SHORT_FNAME
5953 prepend_dot = FALSE; /* nothing to prepend a dot to */
5954 #endif
5955 }
5956 else
5957 {
5958 fnamelen = (int)STRLEN(fname);
5959 retval = alloc((unsigned)(fnamelen + extlen + 3));
5960 if (retval == NULL)
5961 return NULL;
5962 STRCPY(retval, fname);
5963 #ifdef VMS
5964 vms_remove_version(retval); /* we do not need versions here */
5965 #endif
5966 }
5967
5968 /*
5969 * search backwards until we hit a '/', '\' or ':' replacing all '.'
5970 * by '_' for MSDOS or when shortname option set and ext starts with a dot.
5971 * Then truncate what is after the '/', '\' or ':' to 8 characters for
5972 * MSDOS and 26 characters for AMIGA, a lot more for UNIX.
5973 */
5974 for (ptr = retval + fnamelen; ptr > retval; mb_ptr_back(retval, ptr))
5975 {
5976 #ifndef RISCOS
5977 if (*ext == '.'
5978 # ifdef USE_LONG_FNAME
5979 && (!USE_LONG_FNAME || shortname)
5980 # else
5981 # ifndef SHORT_FNAME
5982 && shortname
5983 # endif
5984 # endif
5985 )
5986 if (*ptr == '.') /* replace '.' by '_' */
5987 *ptr = '_';
5988 #endif
5989 if (vim_ispathsep(*ptr))
5990 {
5991 ++ptr;
5992 break;
5993 }
5994 }
5995
5996 /* the file name has at most BASENAMELEN characters. */
5997 #ifndef SHORT_FNAME
5998 if (STRLEN(ptr) > (unsigned)BASENAMELEN)
5999 ptr[BASENAMELEN] = '\0';
6000 #endif
6001
6002 s = ptr + STRLEN(ptr);
6003
6004 /*
6005 * For 8.3 file names we may have to reduce the length.
6006 */
6007 #ifdef USE_LONG_FNAME
6008 if (!USE_LONG_FNAME || shortname)
6009 #else
6010 # ifndef SHORT_FNAME
6011 if (shortname)
6012 # endif
6013 #endif
6014 {
6015 /*
6016 * If there is no file name, or the file name ends in '/', and the
6017 * extension starts with '.', put a '_' before the dot, because just
6018 * ".ext" is invalid.
6019 */
6020 if (fname == NULL || *fname == NUL
6021 || vim_ispathsep(fname[STRLEN(fname) - 1]))
6022 {
6023 #ifdef RISCOS
6024 if (*ext == '/')
6025 #else
6026 if (*ext == '.')
6027 #endif
6028 *s++ = '_';
6029 }
6030 /*
6031 * If the extension starts with '.', truncate the base name at 8
6032 * characters
6033 */
6034 #ifdef RISCOS
6035 /* We normally use '/', but swap files are '_' */
6036 else if (*ext == '/' || *ext == '_')
6037 #else
6038 else if (*ext == '.')
6039 #endif
6040 {
6041 if ((size_t)(s - ptr) > (size_t)8)
6042 {
6043 s = ptr + 8;
6044 *s = '\0';
6045 }
6046 }
6047 /*
6048 * If the extension doesn't start with '.', and the file name
6049 * doesn't have an extension yet, append a '.'
6050 */
6051 #ifdef RISCOS
6052 else if ((e = vim_strchr(ptr, '/')) == NULL)
6053 *s++ = '/';
6054 #else
6055 else if ((e = vim_strchr(ptr, '.')) == NULL)
6056 *s++ = '.';
6057 #endif
6058 /*
6059 * If the extension doesn't start with '.', and there already is an
6060 * extension, it may need to be truncated
6061 */
6062 else if ((int)STRLEN(e) + extlen > 4)
6063 s = e + 4 - extlen;
6064 }
6065 #if defined(OS2) || defined(USE_LONG_FNAME) || defined(WIN3264)
6066 /*
6067 * If there is no file name, and the extension starts with '.', put a
6068 * '_' before the dot, because just ".ext" may be invalid if it's on a
6069 * FAT partition, and on HPFS it doesn't matter.
6070 */
6071 else if ((fname == NULL || *fname == NUL) && *ext == '.')
6072 *s++ = '_';
6073 #endif
6074
6075 /*
6076 * Append the extension.
6077 * ext can start with '.' and cannot exceed 3 more characters.
6078 */
6079 STRCPY(s, ext);
6080
6081 #ifndef SHORT_FNAME
6082 /*
6083 * Prepend the dot.
6084 */
6085 if (prepend_dot && !shortname && *(e = gettail(retval)) !=
6086 #ifdef RISCOS
6087 '/'
6088 #else
6089 '.'
6090 #endif
6091 #ifdef USE_LONG_FNAME
6092 && USE_LONG_FNAME
6093 #endif
6094 )
6095 {
6096 STRMOVE(e + 1, e);
6097 #ifdef RISCOS
6098 *e = '/';
6099 #else
6100 *e = '.';
6101 #endif
6102 }
6103 #endif
6104
6105 /*
6106 * Check that, after appending the extension, the file name is really
6107 * different.
6108 */
6109 if (fname != NULL && STRCMP(fname, retval) == 0)
6110 {
6111 /* we search for a character that can be replaced by '_' */
6112 while (--s >= ptr)
6113 {
6114 if (*s != '_')
6115 {
6116 *s = '_';
6117 break;
6118 }
6119 }
6120 if (s < ptr) /* fname was "________.<ext>", how tricky! */
6121 *ptr = 'v';
6122 }
6123 return retval;
6124 }
6125
6126 /*
6127 * Like fgets(), but if the file line is too long, it is truncated and the
6128 * rest of the line is thrown away. Returns TRUE for end-of-file.
6129 */
6130 int
6131 vim_fgets(buf, size, fp)
6132 char_u *buf;
6133 int size;
6134 FILE *fp;
6135 {
6136 char *eof;
6137 #define FGETS_SIZE 200
6138 char tbuf[FGETS_SIZE];
6139
6140 buf[size - 2] = NUL;
6141 #ifdef USE_CR
6142 eof = fgets_cr((char *)buf, size, fp);
6143 #else
6144 eof = fgets((char *)buf, size, fp);
6145 #endif
6146 if (buf[size - 2] != NUL && buf[size - 2] != '\n')
6147 {
6148 buf[size - 1] = NUL; /* Truncate the line */
6149
6150 /* Now throw away the rest of the line: */
6151 do
6152 {
6153 tbuf[FGETS_SIZE - 2] = NUL;
6154 #ifdef USE_CR
6155 ignoredp = fgets_cr((char *)tbuf, FGETS_SIZE, fp);
6156 #else
6157 ignoredp = fgets((char *)tbuf, FGETS_SIZE, fp);
6158 #endif
6159 } while (tbuf[FGETS_SIZE - 2] != NUL && tbuf[FGETS_SIZE - 2] != '\n');
6160 }
6161 return (eof == NULL);
6162 }
6163
6164 #if defined(USE_CR) || defined(PROTO)
6165 /*
6166 * Like vim_fgets(), but accept any line terminator: CR, CR-LF or LF.
6167 * Returns TRUE for end-of-file.
6168 * Only used for the Mac, because it's much slower than vim_fgets().
6169 */
6170 int
6171 tag_fgets(buf, size, fp)
6172 char_u *buf;
6173 int size;
6174 FILE *fp;
6175 {
6176 int i = 0;
6177 int c;
6178 int eof = FALSE;
6179
6180 for (;;)
6181 {
6182 c = fgetc(fp);
6183 if (c == EOF)
6184 {
6185 eof = TRUE;
6186 break;
6187 }
6188 if (c == '\r')
6189 {
6190 /* Always store a NL for end-of-line. */
6191 if (i < size - 1)
6192 buf[i++] = '\n';
6193 c = fgetc(fp);
6194 if (c != '\n') /* Macintosh format: single CR. */
6195 ungetc(c, fp);
6196 break;
6197 }
6198 if (i < size - 1)
6199 buf[i++] = c;
6200 if (c == '\n')
6201 break;
6202 }
6203 buf[i] = NUL;
6204 return eof;
6205 }
6206 #endif
6207
6208 /*
6209 * rename() only works if both files are on the same file system, this
6210 * function will (attempts to?) copy the file across if rename fails -- webb
6211 * Return -1 for failure, 0 for success.
6212 */
6213 int
6214 vim_rename(from, to)
6215 char_u *from;
6216 char_u *to;
6217 {
6218 int fd_in;
6219 int fd_out;
6220 int n;
6221 char *errmsg = NULL;
6222 char *buffer;
6223 #ifdef AMIGA
6224 BPTR flock;
6225 #endif
6226 struct stat st;
6227 long perm;
6228 #ifdef HAVE_ACL
6229 vim_acl_T acl; /* ACL from original file */
6230 #endif
6231 #if defined(UNIX) || defined(CASE_INSENSITIVE_FILENAME)
6232 int use_tmp_file = FALSE;
6233 #endif
6234
6235 /*
6236 * When the names are identical, there is nothing to do. When they refer
6237 * to the same file (ignoring case and slash/backslash differences) but
6238 * the file name differs we need to go through a temp file.
6239 */
6240 if (fnamecmp(from, to) == 0)
6241 {
6242 #ifdef CASE_INSENSITIVE_FILENAME
6243 if (STRCMP(gettail(from), gettail(to)) != 0)
6244 use_tmp_file = TRUE;
6245 else
6246 #endif
6247 return 0;
6248 }
6249
6250 /*
6251 * Fail if the "from" file doesn't exist. Avoids that "to" is deleted.
6252 */
6253 if (mch_stat((char *)from, &st) < 0)
6254 return -1;
6255
6256 #ifdef UNIX
6257 {
6258 struct stat st_to;
6259
6260 /* It's possible for the source and destination to be the same file.
6261 * This happens when "from" and "to" differ in case and are on a FAT32
6262 * filesystem. In that case go through a temp file name. */
6263 if (mch_stat((char *)to, &st_to) >= 0
6264 && st.st_dev == st_to.st_dev
6265 && st.st_ino == st_to.st_ino)
6266 use_tmp_file = TRUE;
6267 }
6268 #endif
6269
6270 #if defined(UNIX) || defined(CASE_INSENSITIVE_FILENAME)
6271 if (use_tmp_file)
6272 {
6273 char tempname[MAXPATHL + 1];
6274
6275 /*
6276 * Find a name that doesn't exist and is in the same directory.
6277 * Rename "from" to "tempname" and then rename "tempname" to "to".
6278 */
6279 if (STRLEN(from) >= MAXPATHL - 5)
6280 return -1;
6281 STRCPY(tempname, from);
6282 for (n = 123; n < 99999; ++n)
6283 {
6284 sprintf((char *)gettail((char_u *)tempname), "%d", n);
6285 if (mch_stat(tempname, &st) < 0)
6286 {
6287 if (mch_rename((char *)from, tempname) == 0)
6288 {
6289 if (mch_rename(tempname, (char *)to) == 0)
6290 return 0;
6291 /* Strange, the second step failed. Try moving the
6292 * file back and return failure. */
6293 mch_rename(tempname, (char *)from);
6294 return -1;
6295 }
6296 /* If it fails for one temp name it will most likely fail
6297 * for any temp name, give up. */
6298 return -1;
6299 }
6300 }
6301 return -1;
6302 }
6303 #endif
6304
6305 /*
6306 * Delete the "to" file, this is required on some systems to make the
6307 * mch_rename() work, on other systems it makes sure that we don't have
6308 * two files when the mch_rename() fails.
6309 */
6310
6311 #ifdef AMIGA
6312 /*
6313 * With MSDOS-compatible filesystems (crossdos, messydos) it is possible
6314 * that the name of the "to" file is the same as the "from" file, even
6315 * though the names are different. To avoid the chance of accidentally
6316 * deleting the "from" file (horror!) we lock it during the remove.
6317 *
6318 * When used for making a backup before writing the file: This should not
6319 * happen with ":w", because startscript() should detect this problem and
6320 * set buf->b_shortname, causing modname() to return a correct ".bak" file
6321 * name. This problem does exist with ":w filename", but then the
6322 * original file will be somewhere else so the backup isn't really
6323 * important. If autoscripting is off the rename may fail.
6324 */
6325 flock = Lock((UBYTE *)from, (long)ACCESS_READ);
6326 #endif
6327 mch_remove(to);
6328 #ifdef AMIGA
6329 if (flock)
6330 UnLock(flock);
6331 #endif
6332
6333 /*
6334 * First try a normal rename, return if it works.
6335 */
6336 if (mch_rename((char *)from, (char *)to) == 0)
6337 return 0;
6338
6339 /*
6340 * Rename() failed, try copying the file.
6341 */
6342 perm = mch_getperm(from);
6343 #ifdef HAVE_ACL
6344 /* For systems that support ACL: get the ACL from the original file. */
6345 acl = mch_get_acl(from);
6346 #endif
6347 fd_in = mch_open((char *)from, O_RDONLY|O_EXTRA, 0);
6348 if (fd_in == -1)
6349 {
6350 #ifdef HAVE_ACL
6351 mch_free_acl(acl);
6352 #endif
6353 return -1;
6354 }
6355
6356 /* Create the new file with same permissions as the original. */
6357 fd_out = mch_open((char *)to,
6358 O_CREAT|O_EXCL|O_WRONLY|O_EXTRA|O_NOFOLLOW, (int)perm);
6359 if (fd_out == -1)
6360 {
6361 close(fd_in);
6362 #ifdef HAVE_ACL
6363 mch_free_acl(acl);
6364 #endif
6365 return -1;
6366 }
6367
6368 buffer = (char *)alloc(BUFSIZE);
6369 if (buffer == NULL)
6370 {
6371 close(fd_out);
6372 close(fd_in);
6373 #ifdef HAVE_ACL
6374 mch_free_acl(acl);
6375 #endif
6376 return -1;
6377 }
6378
6379 while ((n = vim_read(fd_in, buffer, BUFSIZE)) > 0)
6380 if (vim_write(fd_out, buffer, n) != n)
6381 {
6382 errmsg = _("E208: Error writing to \"%s\"");
6383 break;
6384 }
6385
6386 vim_free(buffer);
6387 close(fd_in);
6388 if (close(fd_out) < 0)
6389 errmsg = _("E209: Error closing \"%s\"");
6390 if (n < 0)
6391 {
6392 errmsg = _("E210: Error reading \"%s\"");
6393 to = from;
6394 }
6395 #ifndef UNIX /* for Unix mch_open() already set the permission */
6396 mch_setperm(to, perm);
6397 #endif
6398 #ifdef HAVE_ACL
6399 mch_set_acl(to, acl);
6400 mch_free_acl(acl);
6401 #endif
6402 if (errmsg != NULL)
6403 {
6404 EMSG2(errmsg, to);
6405 return -1;
6406 }
6407 mch_remove(from);
6408 return 0;
6409 }
6410
6411 static int already_warned = FALSE;
6412
6413 /*
6414 * Check if any not hidden buffer has been changed.
6415 * Postpone the check if there are characters in the stuff buffer, a global
6416 * command is being executed, a mapping is being executed or an autocommand is
6417 * busy.
6418 * Returns TRUE if some message was written (screen should be redrawn and
6419 * cursor positioned).
6420 */
6421 int
6422 check_timestamps(focus)
6423 int focus; /* called for GUI focus event */
6424 {
6425 buf_T *buf;
6426 int didit = 0;
6427 int n;
6428
6429 /* Don't check timestamps while system() or another low-level function may
6430 * cause us to lose and gain focus. */
6431 if (no_check_timestamps > 0)
6432 return FALSE;
6433
6434 /* Avoid doing a check twice. The OK/Reload dialog can cause a focus
6435 * event and we would keep on checking if the file is steadily growing.
6436 * Do check again after typing something. */
6437 if (focus && did_check_timestamps)
6438 {
6439 need_check_timestamps = TRUE;
6440 return FALSE;
6441 }
6442
6443 if (!stuff_empty() || global_busy || !typebuf_typed()
6444 #ifdef FEAT_AUTOCMD
6445 || autocmd_busy || curbuf_lock > 0 || allbuf_lock > 0
6446 #endif
6447 )
6448 need_check_timestamps = TRUE; /* check later */
6449 else
6450 {
6451 ++no_wait_return;
6452 did_check_timestamps = TRUE;
6453 already_warned = FALSE;
6454 for (buf = firstbuf; buf != NULL; )
6455 {
6456 /* Only check buffers in a window. */
6457 if (buf->b_nwindows > 0)
6458 {
6459 n = buf_check_timestamp(buf, focus);
6460 if (didit < n)
6461 didit = n;
6462 if (n > 0 && !buf_valid(buf))
6463 {
6464 /* Autocommands have removed the buffer, start at the
6465 * first one again. */
6466 buf = firstbuf;
6467 continue;
6468 }
6469 }
6470 buf = buf->b_next;
6471 }
6472 --no_wait_return;
6473 need_check_timestamps = FALSE;
6474 if (need_wait_return && didit == 2)
6475 {
6476 /* make sure msg isn't overwritten */
6477 msg_puts((char_u *)"\n");
6478 out_flush();
6479 }
6480 }
6481 return didit;
6482 }
6483
6484 /*
6485 * Move all the lines from buffer "frombuf" to buffer "tobuf".
6486 * Return OK or FAIL. When FAIL "tobuf" is incomplete and/or "frombuf" is not
6487 * empty.
6488 */
6489 static int
6490 move_lines(frombuf, tobuf)
6491 buf_T *frombuf;
6492 buf_T *tobuf;
6493 {
6494 buf_T *tbuf = curbuf;
6495 int retval = OK;
6496 linenr_T lnum;
6497 char_u *p;
6498
6499 /* Copy the lines in "frombuf" to "tobuf". */
6500 curbuf = tobuf;
6501 for (lnum = 1; lnum <= frombuf->b_ml.ml_line_count; ++lnum)
6502 {
6503 p = vim_strsave(ml_get_buf(frombuf, lnum, FALSE));
6504 if (p == NULL || ml_append(lnum - 1, p, 0, FALSE) == FAIL)
6505 {
6506 vim_free(p);
6507 retval = FAIL;
6508 break;
6509 }
6510 vim_free(p);
6511 }
6512
6513 /* Delete all the lines in "frombuf". */
6514 if (retval != FAIL)
6515 {
6516 curbuf = frombuf;
6517 for (lnum = curbuf->b_ml.ml_line_count; lnum > 0; --lnum)
6518 if (ml_delete(lnum, FALSE) == FAIL)
6519 {
6520 /* Oops! We could try putting back the saved lines, but that
6521 * might fail again... */
6522 retval = FAIL;
6523 break;
6524 }
6525 }
6526
6527 curbuf = tbuf;
6528 return retval;
6529 }
6530
6531 /*
6532 * Check if buffer "buf" has been changed.
6533 * Also check if the file for a new buffer unexpectedly appeared.
6534 * return 1 if a changed buffer was found.
6535 * return 2 if a message has been displayed.
6536 * return 0 otherwise.
6537 */
6538 int
6539 buf_check_timestamp(buf, focus)
6540 buf_T *buf;
6541 int focus UNUSED; /* called for GUI focus event */
6542 {
6543 struct stat st;
6544 int stat_res;
6545 int retval = 0;
6546 char_u *path;
6547 char_u *tbuf;
6548 char *mesg = NULL;
6549 char *mesg2 = "";
6550 int helpmesg = FALSE;
6551 int reload = FALSE;
6552 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6553 int can_reload = FALSE;
6554 #endif
6555 size_t orig_size = buf->b_orig_size;
6556 int orig_mode = buf->b_orig_mode;
6557 #ifdef FEAT_GUI
6558 int save_mouse_correct = need_mouse_correct;
6559 #endif
6560 #ifdef FEAT_AUTOCMD
6561 static int busy = FALSE;
6562 int n;
6563 char_u *s;
6564 #endif
6565 char *reason;
6566
6567 /* If there is no file name, the buffer is not loaded, 'buftype' is
6568 * set, we are in the middle of a save or being called recursively: ignore
6569 * this buffer. */
6570 if (buf->b_ffname == NULL
6571 || buf->b_ml.ml_mfp == NULL
6572 #if defined(FEAT_QUICKFIX)
6573 || *buf->b_p_bt != NUL
6574 #endif
6575 || buf->b_saving
6576 #ifdef FEAT_AUTOCMD
6577 || busy
6578 #endif
6579 #ifdef FEAT_NETBEANS_INTG
6580 || isNetbeansBuffer(buf)
6581 #endif
6582 )
6583 return 0;
6584
6585 if ( !(buf->b_flags & BF_NOTEDITED)
6586 && buf->b_mtime != 0
6587 && ((stat_res = mch_stat((char *)buf->b_ffname, &st)) < 0
6588 || time_differs((long)st.st_mtime, buf->b_mtime)
6589 #ifdef HAVE_ST_MODE
6590 || (int)st.st_mode != buf->b_orig_mode
6591 #else
6592 || mch_getperm(buf->b_ffname) != buf->b_orig_mode
6593 #endif
6594 ))
6595 {
6596 retval = 1;
6597
6598 /* set b_mtime to stop further warnings (e.g., when executing
6599 * FileChangedShell autocmd) */
6600 if (stat_res < 0)
6601 {
6602 buf->b_mtime = 0;
6603 buf->b_orig_size = 0;
6604 buf->b_orig_mode = 0;
6605 }
6606 else
6607 buf_store_time(buf, &st, buf->b_ffname);
6608
6609 /* Don't do anything for a directory. Might contain the file
6610 * explorer. */
6611 if (mch_isdir(buf->b_fname))
6612 ;
6613
6614 /*
6615 * If 'autoread' is set, the buffer has no changes and the file still
6616 * exists, reload the buffer. Use the buffer-local option value if it
6617 * was set, the global option value otherwise.
6618 */
6619 else if ((buf->b_p_ar >= 0 ? buf->b_p_ar : p_ar)
6620 && !bufIsChanged(buf) && stat_res >= 0)
6621 reload = TRUE;
6622 else
6623 {
6624 if (stat_res < 0)
6625 reason = "deleted";
6626 else if (bufIsChanged(buf))
6627 reason = "conflict";
6628 else if (orig_size != buf->b_orig_size || buf_contents_changed(buf))
6629 reason = "changed";
6630 else if (orig_mode != buf->b_orig_mode)
6631 reason = "mode";
6632 else
6633 reason = "time";
6634
6635 #ifdef FEAT_AUTOCMD
6636 /*
6637 * Only give the warning if there are no FileChangedShell
6638 * autocommands.
6639 * Avoid being called recursively by setting "busy".
6640 */
6641 busy = TRUE;
6642 # ifdef FEAT_EVAL
6643 set_vim_var_string(VV_FCS_REASON, (char_u *)reason, -1);
6644 set_vim_var_string(VV_FCS_CHOICE, (char_u *)"", -1);
6645 # endif
6646 ++allbuf_lock;
6647 n = apply_autocmds(EVENT_FILECHANGEDSHELL,
6648 buf->b_fname, buf->b_fname, FALSE, buf);
6649 --allbuf_lock;
6650 busy = FALSE;
6651 if (n)
6652 {
6653 if (!buf_valid(buf))
6654 EMSG(_("E246: FileChangedShell autocommand deleted buffer"));
6655 # ifdef FEAT_EVAL
6656 s = get_vim_var_str(VV_FCS_CHOICE);
6657 if (STRCMP(s, "reload") == 0 && *reason != 'd')
6658 reload = TRUE;
6659 else if (STRCMP(s, "ask") == 0)
6660 n = FALSE;
6661 else
6662 # endif
6663 return 2;
6664 }
6665 if (!n)
6666 #endif
6667 {
6668 if (*reason == 'd')
6669 mesg = _("E211: File \"%s\" no longer available");
6670 else
6671 {
6672 helpmesg = TRUE;
6673 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6674 can_reload = TRUE;
6675 #endif
6676 /*
6677 * Check if the file contents really changed to avoid
6678 * giving a warning when only the timestamp was set (e.g.,
6679 * checked out of CVS). Always warn when the buffer was
6680 * changed.
6681 */
6682 if (reason[2] == 'n')
6683 {
6684 mesg = _("W12: Warning: File \"%s\" has changed and the buffer was changed in Vim as well");
6685 mesg2 = _("See \":help W12\" for more info.");
6686 }
6687 else if (reason[1] == 'h')
6688 {
6689 mesg = _("W11: Warning: File \"%s\" has changed since editing started");
6690 mesg2 = _("See \":help W11\" for more info.");
6691 }
6692 else if (*reason == 'm')
6693 {
6694 mesg = _("W16: Warning: Mode of file \"%s\" has changed since editing started");
6695 mesg2 = _("See \":help W16\" for more info.");
6696 }
6697 else
6698 /* Only timestamp changed, store it to avoid a warning
6699 * in check_mtime() later. */
6700 buf->b_mtime_read = buf->b_mtime;
6701 }
6702 }
6703 }
6704
6705 }
6706 else if ((buf->b_flags & BF_NEW) && !(buf->b_flags & BF_NEW_W)
6707 && vim_fexists(buf->b_ffname))
6708 {
6709 retval = 1;
6710 mesg = _("W13: Warning: File \"%s\" has been created after editing started");
6711 buf->b_flags |= BF_NEW_W;
6712 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6713 can_reload = TRUE;
6714 #endif
6715 }
6716
6717 if (mesg != NULL)
6718 {
6719 path = home_replace_save(buf, buf->b_fname);
6720 if (path != NULL)
6721 {
6722 if (!helpmesg)
6723 mesg2 = "";
6724 tbuf = alloc((unsigned)(STRLEN(path) + STRLEN(mesg)
6725 + STRLEN(mesg2) + 2));
6726 sprintf((char *)tbuf, mesg, path);
6727 #ifdef FEAT_EVAL
6728 /* Set warningmsg here, before the unimportant and output-specific
6729 * mesg2 has been appended. */
6730 set_vim_var_string(VV_WARNINGMSG, tbuf, -1);
6731 #endif
6732 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6733 if (can_reload)
6734 {
6735 if (*mesg2 != NUL)
6736 {
6737 STRCAT(tbuf, "\n");
6738 STRCAT(tbuf, mesg2);
6739 }
6740 if (do_dialog(VIM_WARNING, (char_u *)_("Warning"), tbuf,
6741 (char_u *)_("&OK\n&Load File"), 1, NULL) == 2)
6742 reload = TRUE;
6743 }
6744 else
6745 #endif
6746 if (State > NORMAL_BUSY || (State & CMDLINE) || already_warned)
6747 {
6748 if (*mesg2 != NUL)
6749 {
6750 STRCAT(tbuf, "; ");
6751 STRCAT(tbuf, mesg2);
6752 }
6753 EMSG(tbuf);
6754 retval = 2;
6755 }
6756 else
6757 {
6758 # ifdef FEAT_AUTOCMD
6759 if (!autocmd_busy)
6760 # endif
6761 {
6762 msg_start();
6763 msg_puts_attr(tbuf, hl_attr(HLF_E) + MSG_HIST);
6764 if (*mesg2 != NUL)
6765 msg_puts_attr((char_u *)mesg2,
6766 hl_attr(HLF_W) + MSG_HIST);
6767 msg_clr_eos();
6768 (void)msg_end();
6769 if (emsg_silent == 0)
6770 {
6771 out_flush();
6772 # ifdef FEAT_GUI
6773 if (!focus)
6774 # endif
6775 /* give the user some time to think about it */
6776 ui_delay(1000L, TRUE);
6777
6778 /* don't redraw and erase the message */
6779 redraw_cmdline = FALSE;
6780 }
6781 }
6782 already_warned = TRUE;
6783 }
6784
6785 vim_free(path);
6786 vim_free(tbuf);
6787 }
6788 }
6789
6790 if (reload)
6791 /* Reload the buffer. */
6792 buf_reload(buf, orig_mode);
6793
6794 #ifdef FEAT_AUTOCMD
6795 /* Trigger FileChangedShell when the file was changed in any way. */
6796 if (buf_valid(buf) && retval != 0)
6797 (void)apply_autocmds(EVENT_FILECHANGEDSHELLPOST,
6798 buf->b_fname, buf->b_fname, FALSE, buf);
6799 #endif
6800 #ifdef FEAT_GUI
6801 /* restore this in case an autocommand has set it; it would break
6802 * 'mousefocus' */
6803 need_mouse_correct = save_mouse_correct;
6804 #endif
6805
6806 return retval;
6807 }
6808
6809 /*
6810 * Reload a buffer that is already loaded.
6811 * Used when the file was changed outside of Vim.
6812 * "orig_mode" is buf->b_orig_mode before the need for reloading was detected.
6813 * buf->b_orig_mode may have been reset already.
6814 */
6815 void
6816 buf_reload(buf, orig_mode)
6817 buf_T *buf;
6818 int orig_mode;
6819 {
6820 exarg_T ea;
6821 pos_T old_cursor;
6822 linenr_T old_topline;
6823 int old_ro = buf->b_p_ro;
6824 buf_T *savebuf;
6825 int saved = OK;
6826 aco_save_T aco;
6827
6828 /* set curwin/curbuf for "buf" and save some things */
6829 aucmd_prepbuf(&aco, buf);
6830
6831 /* We only want to read the text from the file, not reset the syntax
6832 * highlighting, clear marks, diff status, etc. Force the fileformat
6833 * and encoding to be the same. */
6834 if (prep_exarg(&ea, buf) == OK)
6835 {
6836 old_cursor = curwin->w_cursor;
6837 old_topline = curwin->w_topline;
6838
6839 /*
6840 * To behave like when a new file is edited (matters for
6841 * BufReadPost autocommands) we first need to delete the current
6842 * buffer contents. But if reading the file fails we should keep
6843 * the old contents. Can't use memory only, the file might be
6844 * too big. Use a hidden buffer to move the buffer contents to.
6845 */
6846 if (bufempty())
6847 savebuf = NULL;
6848 else
6849 {
6850 /* Allocate a buffer without putting it in the buffer list. */
6851 savebuf = buflist_new(NULL, NULL, (linenr_T)1, BLN_DUMMY);
6852 if (savebuf != NULL && buf == curbuf)
6853 {
6854 /* Open the memline. */
6855 curbuf = savebuf;
6856 curwin->w_buffer = savebuf;
6857 saved = ml_open(curbuf);
6858 curbuf = buf;
6859 curwin->w_buffer = buf;
6860 }
6861 if (savebuf == NULL || saved == FAIL || buf != curbuf
6862 || move_lines(buf, savebuf) == FAIL)
6863 {
6864 EMSG2(_("E462: Could not prepare for reloading \"%s\""),
6865 buf->b_fname);
6866 saved = FAIL;
6867 }
6868 }
6869
6870 if (saved == OK)
6871 {
6872 curbuf->b_flags |= BF_CHECK_RO; /* check for RO again */
6873 #ifdef FEAT_AUTOCMD
6874 keep_filetype = TRUE; /* don't detect 'filetype' */
6875 #endif
6876 if (readfile(buf->b_ffname, buf->b_fname, (linenr_T)0,
6877 (linenr_T)0,
6878 (linenr_T)MAXLNUM, &ea, READ_NEW) == FAIL)
6879 {
6880 #if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
6881 if (!aborting())
6882 #endif
6883 EMSG2(_("E321: Could not reload \"%s\""), buf->b_fname);
6884 if (savebuf != NULL && buf_valid(savebuf) && buf == curbuf)
6885 {
6886 /* Put the text back from the save buffer. First
6887 * delete any lines that readfile() added. */
6888 while (!bufempty())
6889 if (ml_delete(buf->b_ml.ml_line_count, FALSE) == FAIL)
6890 break;
6891 (void)move_lines(savebuf, buf);
6892 }
6893 }
6894 else if (buf == curbuf)
6895 {
6896 /* Mark the buffer as unmodified and free undo info. */
6897 unchanged(buf, TRUE);
6898 u_blockfree(buf);
6899 u_clearall(buf);
6900 }
6901 }
6902 vim_free(ea.cmd);
6903
6904 if (savebuf != NULL && buf_valid(savebuf))
6905 wipe_buffer(savebuf, FALSE);
6906
6907 #ifdef FEAT_DIFF
6908 /* Invalidate diff info if necessary. */
6909 diff_invalidate(curbuf);
6910 #endif
6911
6912 /* Restore the topline and cursor position and check it (lines may
6913 * have been removed). */
6914 if (old_topline > curbuf->b_ml.ml_line_count)
6915 curwin->w_topline = curbuf->b_ml.ml_line_count;
6916 else
6917 curwin->w_topline = old_topline;
6918 curwin->w_cursor = old_cursor;
6919 check_cursor();
6920 update_topline();
6921 #ifdef FEAT_AUTOCMD
6922 keep_filetype = FALSE;
6923 #endif
6924 #ifdef FEAT_FOLDING
6925 {
6926 win_T *wp;
6927 tabpage_T *tp;
6928
6929 /* Update folds unless they are defined manually. */
6930 FOR_ALL_TAB_WINDOWS(tp, wp)
6931 if (wp->w_buffer == curwin->w_buffer
6932 && !foldmethodIsManual(wp))
6933 foldUpdateAll(wp);
6934 }
6935 #endif
6936 /* If the mode didn't change and 'readonly' was set, keep the old
6937 * value; the user probably used the ":view" command. But don't
6938 * reset it, might have had a read error. */
6939 if (orig_mode == curbuf->b_orig_mode)
6940 curbuf->b_p_ro |= old_ro;
6941 }
6942
6943 /* restore curwin/curbuf and a few other things */
6944 aucmd_restbuf(&aco);
6945 /* Careful: autocommands may have made "buf" invalid! */
6946 }
6947
6948 void
6949 buf_store_time(buf, st, fname)
6950 buf_T *buf;
6951 struct stat *st;
6952 char_u *fname UNUSED;
6953 {
6954 buf->b_mtime = (long)st->st_mtime;
6955 buf->b_orig_size = (size_t)st->st_size;
6956 #ifdef HAVE_ST_MODE
6957 buf->b_orig_mode = (int)st->st_mode;
6958 #else
6959 buf->b_orig_mode = mch_getperm(fname);
6960 #endif
6961 }
6962
6963 /*
6964 * Adjust the line with missing eol, used for the next write.
6965 * Used for do_filter(), when the input lines for the filter are deleted.
6966 */
6967 void
6968 write_lnum_adjust(offset)
6969 linenr_T offset;
6970 {
6971 if (write_no_eol_lnum != 0) /* only if there is a missing eol */
6972 write_no_eol_lnum += offset;
6973 }
6974
6975 #if defined(TEMPDIRNAMES) || defined(PROTO)
6976 static long temp_count = 0; /* Temp filename counter. */
6977
6978 /*
6979 * Delete the temp directory and all files it contains.
6980 */
6981 void
6982 vim_deltempdir()
6983 {
6984 char_u **files;
6985 int file_count;
6986 int i;
6987
6988 if (vim_tempdir != NULL)
6989 {
6990 sprintf((char *)NameBuff, "%s*", vim_tempdir);
6991 if (gen_expand_wildcards(1, &NameBuff, &file_count, &files,
6992 EW_DIR|EW_FILE|EW_SILENT) == OK)
6993 {
6994 for (i = 0; i < file_count; ++i)
6995 mch_remove(files[i]);
6996 FreeWild(file_count, files);
6997 }
6998 gettail(NameBuff)[-1] = NUL;
6999 (void)mch_rmdir(NameBuff);
7000
7001 vim_free(vim_tempdir);
7002 vim_tempdir = NULL;
7003 }
7004 }
7005 #endif
7006
7007 #ifdef TEMPDIRNAMES
7008 /*
7009 * Directory "tempdir" was created. Expand this name to a full path and put
7010 * it in "vim_tempdir". This avoids that using ":cd" would confuse us.
7011 * "tempdir" must be no longer than MAXPATHL.
7012 */
7013 static void
7014 vim_settempdir(tempdir)
7015 char_u *tempdir;
7016 {
7017 char_u *buf;
7018
7019 buf = alloc((unsigned)MAXPATHL + 2);
7020 if (buf != NULL)
7021 {
7022 if (vim_FullName(tempdir, buf, MAXPATHL, FALSE) == FAIL)
7023 STRCPY(buf, tempdir);
7024 # ifdef __EMX__
7025 if (vim_strchr(buf, '/') != NULL)
7026 STRCAT(buf, "/");
7027 else
7028 # endif
7029 add_pathsep(buf);
7030 vim_tempdir = vim_strsave(buf);
7031 vim_free(buf);
7032 }
7033 }
7034 #endif
7035
7036 /*
7037 * vim_tempname(): Return a unique name that can be used for a temp file.
7038 *
7039 * The temp file is NOT created.
7040 *
7041 * The returned pointer is to allocated memory.
7042 * The returned pointer is NULL if no valid name was found.
7043 */
7044 char_u *
7045 vim_tempname(extra_char)
7046 int extra_char UNUSED; /* char to use in the name instead of '?' */
7047 {
7048 #ifdef USE_TMPNAM
7049 char_u itmp[L_tmpnam]; /* use tmpnam() */
7050 #else
7051 char_u itmp[TEMPNAMELEN];
7052 #endif
7053
7054 #ifdef TEMPDIRNAMES
7055 static char *(tempdirs[]) = {TEMPDIRNAMES};
7056 int i;
7057 # ifndef EEXIST
7058 struct stat st;
7059 # endif
7060
7061 /*
7062 * This will create a directory for private use by this instance of Vim.
7063 * This is done once, and the same directory is used for all temp files.
7064 * This method avoids security problems because of symlink attacks et al.
7065 * It's also a bit faster, because we only need to check for an existing
7066 * file when creating the directory and not for each temp file.
7067 */
7068 if (vim_tempdir == NULL)
7069 {
7070 /*
7071 * Try the entries in TEMPDIRNAMES to create the temp directory.
7072 */
7073 for (i = 0; i < (int)(sizeof(tempdirs) / sizeof(char *)); ++i)
7074 {
7075 # ifndef HAVE_MKDTEMP
7076 size_t itmplen;
7077 long nr;
7078 long off;
7079 # endif
7080
7081 /* expand $TMP, leave room for "/v1100000/999999999" */
7082 expand_env((char_u *)tempdirs[i], itmp, TEMPNAMELEN - 20);
7083 if (mch_isdir(itmp)) /* directory exists */
7084 {
7085 # ifdef __EMX__
7086 /* If $TMP contains a forward slash (perhaps using bash or
7087 * tcsh), don't add a backslash, use a forward slash!
7088 * Adding 2 backslashes didn't work. */
7089 if (vim_strchr(itmp, '/') != NULL)
7090 STRCAT(itmp, "/");
7091 else
7092 # endif
7093 add_pathsep(itmp);
7094
7095 # ifdef HAVE_MKDTEMP
7096 /* Leave room for filename */
7097 STRCAT(itmp, "vXXXXXX");
7098 if (mkdtemp((char *)itmp) != NULL)
7099 vim_settempdir(itmp);
7100 # else
7101 /* Get an arbitrary number of up to 6 digits. When it's
7102 * unlikely that it already exists it will be faster,
7103 * otherwise it doesn't matter. The use of mkdir() avoids any
7104 * security problems because of the predictable number. */
7105 nr = (mch_get_pid() + (long)time(NULL)) % 1000000L;
7106 itmplen = STRLEN(itmp);
7107
7108 /* Try up to 10000 different values until we find a name that
7109 * doesn't exist. */
7110 for (off = 0; off < 10000L; ++off)
7111 {
7112 int r;
7113 # if defined(UNIX) || defined(VMS)
7114 mode_t umask_save;
7115 # endif
7116
7117 sprintf((char *)itmp + itmplen, "v%ld", nr + off);
7118 # ifndef EEXIST
7119 /* If mkdir() does not set errno to EEXIST, check for
7120 * existing file here. There is a race condition then,
7121 * although it's fail-safe. */
7122 if (mch_stat((char *)itmp, &st) >= 0)
7123 continue;
7124 # endif
7125 # if defined(UNIX) || defined(VMS)
7126 /* Make sure the umask doesn't remove the executable bit.
7127 * "repl" has been reported to use "177". */
7128 umask_save = umask(077);
7129 # endif
7130 r = vim_mkdir(itmp, 0700);
7131 # if defined(UNIX) || defined(VMS)
7132 (void)umask(umask_save);
7133 # endif
7134 if (r == 0)
7135 {
7136 vim_settempdir(itmp);
7137 break;
7138 }
7139 # ifdef EEXIST
7140 /* If the mkdir() didn't fail because the file/dir exists,
7141 * we probably can't create any dir here, try another
7142 * place. */
7143 if (errno != EEXIST)
7144 # endif
7145 break;
7146 }
7147 # endif /* HAVE_MKDTEMP */
7148 if (vim_tempdir != NULL)
7149 break;
7150 }
7151 }
7152 }
7153
7154 if (vim_tempdir != NULL)
7155 {
7156 /* There is no need to check if the file exists, because we own the
7157 * directory and nobody else creates a file in it. */
7158 sprintf((char *)itmp, "%s%ld", vim_tempdir, temp_count++);
7159 return vim_strsave(itmp);
7160 }
7161
7162 return NULL;
7163
7164 #else /* TEMPDIRNAMES */
7165
7166 # ifdef WIN3264
7167 char szTempFile[_MAX_PATH + 1];
7168 char buf4[4];
7169 char_u *retval;
7170 char_u *p;
7171
7172 STRCPY(itmp, "");
7173 if (GetTempPath(_MAX_PATH, szTempFile) == 0)
7174 szTempFile[0] = NUL; /* GetTempPath() failed, use current dir */
7175 strcpy(buf4, "VIM");
7176 buf4[2] = extra_char; /* make it "VIa", "VIb", etc. */
7177 if (GetTempFileName(szTempFile, buf4, 0, itmp) == 0)
7178 return NULL;
7179 /* GetTempFileName() will create the file, we don't want that */
7180 (void)DeleteFile(itmp);
7181
7182 /* Backslashes in a temp file name cause problems when filtering with
7183 * "sh". NOTE: This also checks 'shellcmdflag' to help those people who
7184 * didn't set 'shellslash'. */
7185 retval = vim_strsave(itmp);
7186 if (*p_shcf == '-' || p_ssl)
7187 for (p = retval; *p; ++p)
7188 if (*p == '\\')
7189 *p = '/';
7190 return retval;
7191
7192 # else /* WIN3264 */
7193
7194 # ifdef USE_TMPNAM
7195 /* tmpnam() will make its own name */
7196 if (*tmpnam((char *)itmp) == NUL)
7197 return NULL;
7198 # else
7199 char_u *p;
7200
7201 # ifdef VMS_TEMPNAM
7202 /* mktemp() is not working on VMS. It seems to be
7203 * a do-nothing function. Therefore we use tempnam().
7204 */
7205 sprintf((char *)itmp, "VIM%c", extra_char);
7206 p = (char_u *)tempnam("tmp:", (char *)itmp);
7207 if (p != NULL)
7208 {
7209 /* VMS will use '.LOG' if we don't explicitly specify an extension,
7210 * and VIM will then be unable to find the file later */
7211 STRCPY(itmp, p);
7212 STRCAT(itmp, ".txt");
7213 free(p);
7214 }
7215 else
7216 return NULL;
7217 # else
7218 STRCPY(itmp, TEMPNAME);
7219 if ((p = vim_strchr(itmp, '?')) != NULL)
7220 *p = extra_char;
7221 if (mktemp((char *)itmp) == NULL)
7222 return NULL;
7223 # endif
7224 # endif
7225
7226 return vim_strsave(itmp);
7227 # endif /* WIN3264 */
7228 #endif /* TEMPDIRNAMES */
7229 }
7230
7231 #if defined(BACKSLASH_IN_FILENAME) || defined(PROTO)
7232 /*
7233 * Convert all backslashes in fname to forward slashes in-place.
7234 */
7235 void
7236 forward_slash(fname)
7237 char_u *fname;
7238 {
7239 char_u *p;
7240
7241 for (p = fname; *p != NUL; ++p)
7242 # ifdef FEAT_MBYTE
7243 /* The Big5 encoding can have '\' in the trail byte. */
7244 if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
7245 ++p;
7246 else
7247 # endif
7248 if (*p == '\\')
7249 *p = '/';
7250 }
7251 #endif
7252
7253
7254 /*
7255 * Code for automatic commands.
7256 *
7257 * Only included when "FEAT_AUTOCMD" has been defined.
7258 */
7259
7260 #if defined(FEAT_AUTOCMD) || defined(PROTO)
7261
7262 /*
7263 * The autocommands are stored in a list for each event.
7264 * Autocommands for the same pattern, that are consecutive, are joined
7265 * together, to avoid having to match the pattern too often.
7266 * The result is an array of Autopat lists, which point to AutoCmd lists:
7267 *
7268 * first_autopat[0] --> Autopat.next --> Autopat.next --> NULL
7269 * Autopat.cmds Autopat.cmds
7270 * | |
7271 * V V
7272 * AutoCmd.next AutoCmd.next
7273 * | |
7274 * V V
7275 * AutoCmd.next NULL
7276 * |
7277 * V
7278 * NULL
7279 *
7280 * first_autopat[1] --> Autopat.next --> NULL
7281 * Autopat.cmds
7282 * |
7283 * V
7284 * AutoCmd.next
7285 * |
7286 * V
7287 * NULL
7288 * etc.
7289 *
7290 * The order of AutoCmds is important, this is the order in which they were
7291 * defined and will have to be executed.
7292 */
7293 typedef struct AutoCmd
7294 {
7295 char_u *cmd; /* The command to be executed (NULL
7296 when command has been removed) */
7297 char nested; /* If autocommands nest here */
7298 char last; /* last command in list */
7299 #ifdef FEAT_EVAL
7300 scid_T scriptID; /* script ID where defined */
7301 #endif
7302 struct AutoCmd *next; /* Next AutoCmd in list */
7303 } AutoCmd;
7304
7305 typedef struct AutoPat
7306 {
7307 int group; /* group ID */
7308 char_u *pat; /* pattern as typed (NULL when pattern
7309 has been removed) */
7310 int patlen; /* strlen() of pat */
7311 regprog_T *reg_prog; /* compiled regprog for pattern */
7312 char allow_dirs; /* Pattern may match whole path */
7313 char last; /* last pattern for apply_autocmds() */
7314 AutoCmd *cmds; /* list of commands to do */
7315 struct AutoPat *next; /* next AutoPat in AutoPat list */
7316 int buflocal_nr; /* !=0 for buffer-local AutoPat */
7317 } AutoPat;
7318
7319 static struct event_name
7320 {
7321 char *name; /* event name */
7322 event_T event; /* event number */
7323 } event_names[] =
7324 {
7325 {"BufAdd", EVENT_BUFADD},
7326 {"BufCreate", EVENT_BUFADD},
7327 {"BufDelete", EVENT_BUFDELETE},
7328 {"BufEnter", EVENT_BUFENTER},
7329 {"BufFilePost", EVENT_BUFFILEPOST},
7330 {"BufFilePre", EVENT_BUFFILEPRE},
7331 {"BufHidden", EVENT_BUFHIDDEN},
7332 {"BufLeave", EVENT_BUFLEAVE},
7333 {"BufNew", EVENT_BUFNEW},
7334 {"BufNewFile", EVENT_BUFNEWFILE},
7335 {"BufRead", EVENT_BUFREADPOST},
7336 {"BufReadCmd", EVENT_BUFREADCMD},
7337 {"BufReadPost", EVENT_BUFREADPOST},
7338 {"BufReadPre", EVENT_BUFREADPRE},
7339 {"BufUnload", EVENT_BUFUNLOAD},
7340 {"BufWinEnter", EVENT_BUFWINENTER},
7341 {"BufWinLeave", EVENT_BUFWINLEAVE},
7342 {"BufWipeout", EVENT_BUFWIPEOUT},
7343 {"BufWrite", EVENT_BUFWRITEPRE},
7344 {"BufWritePost", EVENT_BUFWRITEPOST},
7345 {"BufWritePre", EVENT_BUFWRITEPRE},
7346 {"BufWriteCmd", EVENT_BUFWRITECMD},
7347 {"CmdwinEnter", EVENT_CMDWINENTER},
7348 {"CmdwinLeave", EVENT_CMDWINLEAVE},
7349 {"ColorScheme", EVENT_COLORSCHEME},
7350 {"CursorHold", EVENT_CURSORHOLD},
7351 {"CursorHoldI", EVENT_CURSORHOLDI},
7352 {"CursorMoved", EVENT_CURSORMOVED},
7353 {"CursorMovedI", EVENT_CURSORMOVEDI},
7354 {"EncodingChanged", EVENT_ENCODINGCHANGED},
7355 {"FileEncoding", EVENT_ENCODINGCHANGED},
7356 {"FileAppendPost", EVENT_FILEAPPENDPOST},
7357 {"FileAppendPre", EVENT_FILEAPPENDPRE},
7358 {"FileAppendCmd", EVENT_FILEAPPENDCMD},
7359 {"FileChangedShell",EVENT_FILECHANGEDSHELL},
7360 {"FileChangedShellPost",EVENT_FILECHANGEDSHELLPOST},
7361 {"FileChangedRO", EVENT_FILECHANGEDRO},
7362 {"FileReadPost", EVENT_FILEREADPOST},
7363 {"FileReadPre", EVENT_FILEREADPRE},
7364 {"FileReadCmd", EVENT_FILEREADCMD},
7365 {"FileType", EVENT_FILETYPE},
7366 {"FileWritePost", EVENT_FILEWRITEPOST},
7367 {"FileWritePre", EVENT_FILEWRITEPRE},
7368 {"FileWriteCmd", EVENT_FILEWRITECMD},
7369 {"FilterReadPost", EVENT_FILTERREADPOST},
7370 {"FilterReadPre", EVENT_FILTERREADPRE},
7371 {"FilterWritePost", EVENT_FILTERWRITEPOST},
7372 {"FilterWritePre", EVENT_FILTERWRITEPRE},
7373 {"FocusGained", EVENT_FOCUSGAINED},
7374 {"FocusLost", EVENT_FOCUSLOST},
7375 {"FuncUndefined", EVENT_FUNCUNDEFINED},
7376 {"GUIEnter", EVENT_GUIENTER},
7377 {"GUIFailed", EVENT_GUIFAILED},
7378 {"InsertChange", EVENT_INSERTCHANGE},
7379 {"InsertEnter", EVENT_INSERTENTER},
7380 {"InsertLeave", EVENT_INSERTLEAVE},
7381 {"MenuPopup", EVENT_MENUPOPUP},
7382 {"QuickFixCmdPost", EVENT_QUICKFIXCMDPOST},
7383 {"QuickFixCmdPre", EVENT_QUICKFIXCMDPRE},
7384 {"RemoteReply", EVENT_REMOTEREPLY},
7385 {"SessionLoadPost", EVENT_SESSIONLOADPOST},
7386 {"ShellCmdPost", EVENT_SHELLCMDPOST},
7387 {"ShellFilterPost", EVENT_SHELLFILTERPOST},
7388 {"SourcePre", EVENT_SOURCEPRE},
7389 {"SourceCmd", EVENT_SOURCECMD},
7390 {"SpellFileMissing",EVENT_SPELLFILEMISSING},
7391 {"StdinReadPost", EVENT_STDINREADPOST},
7392 {"StdinReadPre", EVENT_STDINREADPRE},
7393 {"SwapExists", EVENT_SWAPEXISTS},
7394 {"Syntax", EVENT_SYNTAX},
7395 {"TabEnter", EVENT_TABENTER},
7396 {"TabLeave", EVENT_TABLEAVE},
7397 {"TermChanged", EVENT_TERMCHANGED},
7398 {"TermResponse", EVENT_TERMRESPONSE},
7399 {"User", EVENT_USER},
7400 {"VimEnter", EVENT_VIMENTER},
7401 {"VimLeave", EVENT_VIMLEAVE},
7402 {"VimLeavePre", EVENT_VIMLEAVEPRE},
7403 {"WinEnter", EVENT_WINENTER},
7404 {"WinLeave", EVENT_WINLEAVE},
7405 {"VimResized", EVENT_VIMRESIZED},
7406 {NULL, (event_T)0}
7407 };
7408
7409 static AutoPat *first_autopat[NUM_EVENTS] =
7410 {
7411 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7412 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7413 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7414 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7415 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7416 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
7417 };
7418
7419 /*
7420 * struct used to keep status while executing autocommands for an event.
7421 */
7422 typedef struct AutoPatCmd
7423 {
7424 AutoPat *curpat; /* next AutoPat to examine */
7425 AutoCmd *nextcmd; /* next AutoCmd to execute */
7426 int group; /* group being used */
7427 char_u *fname; /* fname to match with */
7428 char_u *sfname; /* sfname to match with */
7429 char_u *tail; /* tail of fname */
7430 event_T event; /* current event */
7431 int arg_bufnr; /* initially equal to <abuf>, set to zero when
7432 buf is deleted */
7433 struct AutoPatCmd *next; /* chain of active apc-s for auto-invalidation*/
7434 } AutoPatCmd;
7435
7436 static AutoPatCmd *active_apc_list = NULL; /* stack of active autocommands */
7437
7438 /*
7439 * augroups stores a list of autocmd group names.
7440 */
7441 static garray_T augroups = {0, 0, sizeof(char_u *), 10, NULL};
7442 #define AUGROUP_NAME(i) (((char_u **)augroups.ga_data)[i])
7443
7444 /*
7445 * The ID of the current group. Group 0 is the default one.
7446 */
7447 static int current_augroup = AUGROUP_DEFAULT;
7448
7449 static int au_need_clean = FALSE; /* need to delete marked patterns */
7450
7451 static void show_autocmd __ARGS((AutoPat *ap, event_T event));
7452 static void au_remove_pat __ARGS((AutoPat *ap));
7453 static void au_remove_cmds __ARGS((AutoPat *ap));
7454 static void au_cleanup __ARGS((void));
7455 static int au_new_group __ARGS((char_u *name));
7456 static void au_del_group __ARGS((char_u *name));
7457 static event_T event_name2nr __ARGS((char_u *start, char_u **end));
7458 static char_u *event_nr2name __ARGS((event_T event));
7459 static char_u *find_end_event __ARGS((char_u *arg, int have_group));
7460 static int event_ignored __ARGS((event_T event));
7461 static int au_get_grouparg __ARGS((char_u **argp));
7462 static int do_autocmd_event __ARGS((event_T event, char_u *pat, int nested, char_u *cmd, int forceit, int group));
7463 static char_u *getnextac __ARGS((int c, void *cookie, int indent));
7464 static int apply_autocmds_group __ARGS((event_T event, char_u *fname, char_u *fname_io, int force, int group, buf_T *buf, exarg_T *eap));
7465 static void auto_next_pat __ARGS((AutoPatCmd *apc, int stop_at_last));
7466
7467
7468 static event_T last_event;
7469 static int last_group;
7470 static int autocmd_blocked = 0; /* block all autocmds */
7471
7472 /*
7473 * Show the autocommands for one AutoPat.
7474 */
7475 static void
7476 show_autocmd(ap, event)
7477 AutoPat *ap;
7478 event_T event;
7479 {
7480 AutoCmd *ac;
7481
7482 /* Check for "got_int" (here and at various places below), which is set
7483 * when "q" has been hit for the "--more--" prompt */
7484 if (got_int)
7485 return;
7486 if (ap->pat == NULL) /* pattern has been removed */
7487 return;
7488
7489 msg_putchar('\n');
7490 if (got_int)
7491 return;
7492 if (event != last_event || ap->group != last_group)
7493 {
7494 if (ap->group != AUGROUP_DEFAULT)
7495 {
7496 if (AUGROUP_NAME(ap->group) == NULL)
7497 msg_puts_attr((char_u *)_("--Deleted--"), hl_attr(HLF_E));
7498 else
7499 msg_puts_attr(AUGROUP_NAME(ap->group), hl_attr(HLF_T));
7500 msg_puts((char_u *)" ");
7501 }
7502 msg_puts_attr(event_nr2name(event), hl_attr(HLF_T));
7503 last_event = event;
7504 last_group = ap->group;
7505 msg_putchar('\n');
7506 if (got_int)
7507 return;
7508 }
7509 msg_col = 4;
7510 msg_outtrans(ap->pat);
7511
7512 for (ac = ap->cmds; ac != NULL; ac = ac->next)
7513 {
7514 if (ac->cmd != NULL) /* skip removed commands */
7515 {
7516 if (msg_col >= 14)
7517 msg_putchar('\n');
7518 msg_col = 14;
7519 if (got_int)
7520 return;
7521 msg_outtrans(ac->cmd);
7522 #ifdef FEAT_EVAL
7523 if (p_verbose > 0)
7524 last_set_msg(ac->scriptID);
7525 #endif
7526 if (got_int)
7527 return;
7528 if (ac->next != NULL)
7529 {
7530 msg_putchar('\n');
7531 if (got_int)
7532 return;
7533 }
7534 }
7535 }
7536 }
7537
7538 /*
7539 * Mark an autocommand pattern for deletion.
7540 */
7541 static void
7542 au_remove_pat(ap)
7543 AutoPat *ap;
7544 {
7545 vim_free(ap->pat);
7546 ap->pat = NULL;
7547 ap->buflocal_nr = -1;
7548 au_need_clean = TRUE;
7549 }
7550
7551 /*
7552 * Mark all commands for a pattern for deletion.
7553 */
7554 static void
7555 au_remove_cmds(ap)
7556 AutoPat *ap;
7557 {
7558 AutoCmd *ac;
7559
7560 for (ac = ap->cmds; ac != NULL; ac = ac->next)
7561 {
7562 vim_free(ac->cmd);
7563 ac->cmd = NULL;
7564 }
7565 au_need_clean = TRUE;
7566 }
7567
7568 /*
7569 * Cleanup autocommands and patterns that have been deleted.
7570 * This is only done when not executing autocommands.
7571 */
7572 static void
7573 au_cleanup()
7574 {
7575 AutoPat *ap, **prev_ap;
7576 AutoCmd *ac, **prev_ac;
7577 event_T event;
7578
7579 if (autocmd_busy || !au_need_clean)
7580 return;
7581
7582 /* loop over all events */
7583 for (event = (event_T)0; (int)event < (int)NUM_EVENTS;
7584 event = (event_T)((int)event + 1))
7585 {
7586 /* loop over all autocommand patterns */
7587 prev_ap = &(first_autopat[(int)event]);
7588 for (ap = *prev_ap; ap != NULL; ap = *prev_ap)
7589 {
7590 /* loop over all commands for this pattern */
7591 prev_ac = &(ap->cmds);
7592 for (ac = *prev_ac; ac != NULL; ac = *prev_ac)
7593 {
7594 /* remove the command if the pattern is to be deleted or when
7595 * the command has been marked for deletion */
7596 if (ap->pat == NULL || ac->cmd == NULL)
7597 {
7598 *prev_ac = ac->next;
7599 vim_free(ac->cmd);
7600 vim_free(ac);
7601 }
7602 else
7603 prev_ac = &(ac->next);
7604 }
7605
7606 /* remove the pattern if it has been marked for deletion */
7607 if (ap->pat == NULL)
7608 {
7609 *prev_ap = ap->next;
7610 vim_free(ap->reg_prog);
7611 vim_free(ap);
7612 }
7613 else
7614 prev_ap = &(ap->next);
7615 }
7616 }
7617
7618 au_need_clean = FALSE;
7619 }
7620
7621 /*
7622 * Called when buffer is freed, to remove/invalidate related buffer-local
7623 * autocmds.
7624 */
7625 void
7626 aubuflocal_remove(buf)
7627 buf_T *buf;
7628 {
7629 AutoPat *ap;
7630 event_T event;
7631 AutoPatCmd *apc;
7632
7633 /* invalidate currently executing autocommands */
7634 for (apc = active_apc_list; apc; apc = apc->next)
7635 if (buf->b_fnum == apc->arg_bufnr)
7636 apc->arg_bufnr = 0;
7637
7638 /* invalidate buflocals looping through events */
7639 for (event = (event_T)0; (int)event < (int)NUM_EVENTS;
7640 event = (event_T)((int)event + 1))
7641 /* loop over all autocommand patterns */
7642 for (ap = first_autopat[(int)event]; ap != NULL; ap = ap->next)
7643 if (ap->buflocal_nr == buf->b_fnum)
7644 {
7645 au_remove_pat(ap);
7646 if (p_verbose >= 6)
7647 {
7648 verbose_enter();
7649 smsg((char_u *)
7650 _("auto-removing autocommand: %s <buffer=%d>"),
7651 event_nr2name(event), buf->b_fnum);
7652 verbose_leave();
7653 }
7654 }
7655 au_cleanup();
7656 }
7657
7658 /*
7659 * Add an autocmd group name.
7660 * Return it's ID. Returns AUGROUP_ERROR (< 0) for error.
7661 */
7662 static int
7663 au_new_group(name)
7664 char_u *name;
7665 {
7666 int i;
7667
7668 i = au_find_group(name);
7669 if (i == AUGROUP_ERROR) /* the group doesn't exist yet, add it */
7670 {
7671 /* First try using a free entry. */
7672 for (i = 0; i < augroups.ga_len; ++i)
7673 if (AUGROUP_NAME(i) == NULL)
7674 break;
7675 if (i == augroups.ga_len && ga_grow(&augroups, 1) == FAIL)
7676 return AUGROUP_ERROR;
7677
7678 AUGROUP_NAME(i) = vim_strsave(name);
7679 if (AUGROUP_NAME(i) == NULL)
7680 return AUGROUP_ERROR;
7681 if (i == augroups.ga_len)
7682 ++augroups.ga_len;
7683 }
7684
7685 return i;
7686 }
7687
7688 static void
7689 au_del_group(name)
7690 char_u *name;
7691 {
7692 int i;
7693
7694 i = au_find_group(name);
7695 if (i == AUGROUP_ERROR) /* the group doesn't exist */
7696 EMSG2(_("E367: No such group: \"%s\""), name);
7697 else
7698 {
7699 vim_free(AUGROUP_NAME(i));
7700 AUGROUP_NAME(i) = NULL;
7701 }
7702 }
7703
7704 /*
7705 * Find the ID of an autocmd group name.
7706 * Return it's ID. Returns AUGROUP_ERROR (< 0) for error.
7707 */
7708 static int
7709 au_find_group(name)
7710 char_u *name;
7711 {
7712 int i;
7713
7714 for (i = 0; i < augroups.ga_len; ++i)
7715 if (AUGROUP_NAME(i) != NULL && STRCMP(AUGROUP_NAME(i), name) == 0)
7716 return i;
7717 return AUGROUP_ERROR;
7718 }
7719
7720 /*
7721 * Return TRUE if augroup "name" exists.
7722 */
7723 int
7724 au_has_group(name)
7725 char_u *name;
7726 {
7727 return au_find_group(name) != AUGROUP_ERROR;
7728 }
7729
7730 /*
7731 * ":augroup {name}".
7732 */
7733 void
7734 do_augroup(arg, del_group)
7735 char_u *arg;
7736 int del_group;
7737 {
7738 int i;
7739
7740 if (del_group)
7741 {
7742 if (*arg == NUL)
7743 EMSG(_(e_argreq));
7744 else
7745 au_del_group(arg);
7746 }
7747 else if (STRICMP(arg, "end") == 0) /* ":aug end": back to group 0 */
7748 current_augroup = AUGROUP_DEFAULT;
7749 else if (*arg) /* ":aug xxx": switch to group xxx */
7750 {
7751 i = au_new_group(arg);
7752 if (i != AUGROUP_ERROR)
7753 current_augroup = i;
7754 }
7755 else /* ":aug": list the group names */
7756 {
7757 msg_start();
7758 for (i = 0; i < augroups.ga_len; ++i)
7759 {
7760 if (AUGROUP_NAME(i) != NULL)
7761 {
7762 msg_puts(AUGROUP_NAME(i));
7763 msg_puts((char_u *)" ");
7764 }
7765 }
7766 msg_clr_eos();
7767 msg_end();
7768 }
7769 }
7770
7771 #if defined(EXITFREE) || defined(PROTO)
7772 void
7773 free_all_autocmds()
7774 {
7775 for (current_augroup = -1; current_augroup < augroups.ga_len;
7776 ++current_augroup)
7777 do_autocmd((char_u *)"", TRUE);
7778 ga_clear_strings(&augroups);
7779 }
7780 #endif
7781
7782 /*
7783 * Return the event number for event name "start".
7784 * Return NUM_EVENTS if the event name was not found.
7785 * Return a pointer to the next event name in "end".
7786 */
7787 static event_T
7788 event_name2nr(start, end)
7789 char_u *start;
7790 char_u **end;
7791 {
7792 char_u *p;
7793 int i;
7794 int len;
7795
7796 /* the event name ends with end of line, a blank or a comma */
7797 for (p = start; *p && !vim_iswhite(*p) && *p != ','; ++p)
7798 ;
7799 for (i = 0; event_names[i].name != NULL; ++i)
7800 {
7801 len = (int)STRLEN(event_names[i].name);
7802 if (len == p - start && STRNICMP(event_names[i].name, start, len) == 0)
7803 break;
7804 }
7805 if (*p == ',')
7806 ++p;
7807 *end = p;
7808 if (event_names[i].name == NULL)
7809 return NUM_EVENTS;
7810 return event_names[i].event;
7811 }
7812
7813 /*
7814 * Return the name for event "event".
7815 */
7816 static char_u *
7817 event_nr2name(event)
7818 event_T event;
7819 {
7820 int i;
7821
7822 for (i = 0; event_names[i].name != NULL; ++i)
7823 if (event_names[i].event == event)
7824 return (char_u *)event_names[i].name;
7825 return (char_u *)"Unknown";
7826 }
7827
7828 /*
7829 * Scan over the events. "*" stands for all events.
7830 */
7831 static char_u *
7832 find_end_event(arg, have_group)
7833 char_u *arg;
7834 int have_group; /* TRUE when group name was found */
7835 {
7836 char_u *pat;
7837 char_u *p;
7838
7839 if (*arg == '*')
7840 {
7841 if (arg[1] && !vim_iswhite(arg[1]))
7842 {
7843 EMSG2(_("E215: Illegal character after *: %s"), arg);
7844 return NULL;
7845 }
7846 pat = arg + 1;
7847 }
7848 else
7849 {
7850 for (pat = arg; *pat && !vim_iswhite(*pat); pat = p)
7851 {
7852 if ((int)event_name2nr(pat, &p) >= (int)NUM_EVENTS)
7853 {
7854 if (have_group)
7855 EMSG2(_("E216: No such event: %s"), pat);
7856 else
7857 EMSG2(_("E216: No such group or event: %s"), pat);
7858 return NULL;
7859 }
7860 }
7861 }
7862 return pat;
7863 }
7864
7865 /*
7866 * Return TRUE if "event" is included in 'eventignore'.
7867 */
7868 static int
7869 event_ignored(event)
7870 event_T event;
7871 {
7872 char_u *p = p_ei;
7873
7874 while (*p != NUL)
7875 {
7876 if (STRNICMP(p, "all", 3) == 0 && (p[3] == NUL || p[3] == ','))
7877 return TRUE;
7878 if (event_name2nr(p, &p) == event)
7879 return TRUE;
7880 }
7881
7882 return FALSE;
7883 }
7884
7885 /*
7886 * Return OK when the contents of p_ei is valid, FAIL otherwise.
7887 */
7888 int
7889 check_ei()
7890 {
7891 char_u *p = p_ei;
7892
7893 while (*p)
7894 {
7895 if (STRNICMP(p, "all", 3) == 0 && (p[3] == NUL || p[3] == ','))
7896 {
7897 p += 3;
7898 if (*p == ',')
7899 ++p;
7900 }
7901 else if (event_name2nr(p, &p) == NUM_EVENTS)
7902 return FAIL;
7903 }
7904
7905 return OK;
7906 }
7907
7908 # if defined(FEAT_SYN_HL) || defined(PROTO)
7909
7910 /*
7911 * Add "what" to 'eventignore' to skip loading syntax highlighting for every
7912 * buffer loaded into the window. "what" must start with a comma.
7913 * Returns the old value of 'eventignore' in allocated memory.
7914 */
7915 char_u *
7916 au_event_disable(what)
7917 char *what;
7918 {
7919 char_u *new_ei;
7920 char_u *save_ei;
7921
7922 save_ei = vim_strsave(p_ei);
7923 if (save_ei != NULL)
7924 {
7925 new_ei = vim_strnsave(p_ei, (int)(STRLEN(p_ei) + STRLEN(what)));
7926 if (new_ei != NULL)
7927 {
7928 if (*what == ',' && *p_ei == NUL)
7929 STRCPY(new_ei, what + 1);
7930 else
7931 STRCAT(new_ei, what);
7932 set_string_option_direct((char_u *)"ei", -1, new_ei,
7933 OPT_FREE, SID_NONE);
7934 vim_free(new_ei);
7935 }
7936 }
7937 return save_ei;
7938 }
7939
7940 void
7941 au_event_restore(old_ei)
7942 char_u *old_ei;
7943 {
7944 if (old_ei != NULL)
7945 {
7946 set_string_option_direct((char_u *)"ei", -1, old_ei,
7947 OPT_FREE, SID_NONE);
7948 vim_free(old_ei);
7949 }
7950 }
7951 # endif /* FEAT_SYN_HL */
7952
7953 /*
7954 * do_autocmd() -- implements the :autocmd command. Can be used in the
7955 * following ways:
7956 *
7957 * :autocmd <event> <pat> <cmd> Add <cmd> to the list of commands that
7958 * will be automatically executed for <event>
7959 * when editing a file matching <pat>, in
7960 * the current group.
7961 * :autocmd <event> <pat> Show the auto-commands associated with
7962 * <event> and <pat>.
7963 * :autocmd <event> Show the auto-commands associated with
7964 * <event>.
7965 * :autocmd Show all auto-commands.
7966 * :autocmd! <event> <pat> <cmd> Remove all auto-commands associated with
7967 * <event> and <pat>, and add the command
7968 * <cmd>, for the current group.
7969 * :autocmd! <event> <pat> Remove all auto-commands associated with
7970 * <event> and <pat> for the current group.
7971 * :autocmd! <event> Remove all auto-commands associated with
7972 * <event> for the current group.
7973 * :autocmd! Remove ALL auto-commands for the current
7974 * group.
7975 *
7976 * Multiple events and patterns may be given separated by commas. Here are
7977 * some examples:
7978 * :autocmd bufread,bufenter *.c,*.h set tw=0 smartindent noic
7979 * :autocmd bufleave * set tw=79 nosmartindent ic infercase
7980 *
7981 * :autocmd * *.c show all autocommands for *.c files.
7982 *
7983 * Mostly a {group} argument can optionally appear before <event>.
7984 */
7985 void
7986 do_autocmd(arg, forceit)
7987 char_u *arg;
7988 int forceit;
7989 {
7990 char_u *pat;
7991 char_u *envpat = NULL;
7992 char_u *cmd;
7993 event_T event;
7994 int need_free = FALSE;
7995 int nested = FALSE;
7996 int group;
7997
7998 /*
7999 * Check for a legal group name. If not, use AUGROUP_ALL.
8000 */
8001 group = au_get_grouparg(&arg);
8002 if (arg == NULL) /* out of memory */
8003 return;
8004
8005 /*
8006 * Scan over the events.
8007 * If we find an illegal name, return here, don't do anything.
8008 */
8009 pat = find_end_event(arg, group != AUGROUP_ALL);
8010 if (pat == NULL)
8011 return;
8012
8013 /*
8014 * Scan over the pattern. Put a NUL at the end.
8015 */
8016 pat = skipwhite(pat);
8017 cmd = pat;
8018 while (*cmd && (!vim_iswhite(*cmd) || cmd[-1] == '\\'))
8019 cmd++;
8020 if (*cmd)
8021 *cmd++ = NUL;
8022
8023 /* Expand environment variables in the pattern. Set 'shellslash', we want
8024 * forward slashes here. */
8025 if (vim_strchr(pat, '$') != NULL || vim_strchr(pat, '~') != NULL)
8026 {
8027 #ifdef BACKSLASH_IN_FILENAME
8028 int p_ssl_save = p_ssl;
8029
8030 p_ssl = TRUE;
8031 #endif
8032 envpat = expand_env_save(pat);
8033 #ifdef BACKSLASH_IN_FILENAME
8034 p_ssl = p_ssl_save;
8035 #endif
8036 if (envpat != NULL)
8037 pat = envpat;
8038 }
8039
8040 /*
8041 * Check for "nested" flag.
8042 */
8043 cmd = skipwhite(cmd);
8044 if (*cmd != NUL && STRNCMP(cmd, "nested", 6) == 0 && vim_iswhite(cmd[6]))
8045 {
8046 nested = TRUE;
8047 cmd = skipwhite(cmd + 6);
8048 }
8049
8050 /*
8051 * Find the start of the commands.
8052 * Expand <sfile> in it.
8053 */
8054 if (*cmd != NUL)
8055 {
8056 cmd = expand_sfile(cmd);
8057 if (cmd == NULL) /* some error */
8058 return;
8059 need_free = TRUE;
8060 }
8061
8062 /*
8063 * Print header when showing autocommands.
8064 */
8065 if (!forceit && *cmd == NUL)
8066 {
8067 /* Highlight title */
8068 MSG_PUTS_TITLE(_("\n--- Auto-Commands ---"));
8069 }
8070
8071 /*
8072 * Loop over the events.
8073 */
8074 last_event = (event_T)-1; /* for listing the event name */
8075 last_group = AUGROUP_ERROR; /* for listing the group name */
8076 if (*arg == '*' || *arg == NUL)
8077 {
8078 for (event = (event_T)0; (int)event < (int)NUM_EVENTS;
8079 event = (event_T)((int)event + 1))
8080 if (do_autocmd_event(event, pat,
8081 nested, cmd, forceit, group) == FAIL)
8082 break;
8083 }
8084 else
8085 {
8086 while (*arg && !vim_iswhite(*arg))
8087 if (do_autocmd_event(event_name2nr(arg, &arg), pat,
8088 nested, cmd, forceit, group) == FAIL)
8089 break;
8090 }
8091
8092 if (need_free)
8093 vim_free(cmd);
8094 vim_free(envpat);
8095 }
8096
8097 /*
8098 * Find the group ID in a ":autocmd" or ":doautocmd" argument.
8099 * The "argp" argument is advanced to the following argument.
8100 *
8101 * Returns the group ID, AUGROUP_ERROR for error (out of memory).
8102 */
8103 static int
8104 au_get_grouparg(argp)
8105 char_u **argp;
8106 {
8107 char_u *group_name;
8108 char_u *p;
8109 char_u *arg = *argp;
8110 int group = AUGROUP_ALL;
8111
8112 p = skiptowhite(arg);
8113 if (p > arg)
8114 {
8115 group_name = vim_strnsave(arg, (int)(p - arg));
8116 if (group_name == NULL) /* out of memory */
8117 return AUGROUP_ERROR;
8118 group = au_find_group(group_name);
8119 if (group == AUGROUP_ERROR)
8120 group = AUGROUP_ALL; /* no match, use all groups */
8121 else
8122 *argp = skipwhite(p); /* match, skip over group name */
8123 vim_free(group_name);
8124 }
8125 return group;
8126 }
8127
8128 /*
8129 * do_autocmd() for one event.
8130 * If *pat == NUL do for all patterns.
8131 * If *cmd == NUL show entries.
8132 * If forceit == TRUE delete entries.
8133 * If group is not AUGROUP_ALL, only use this group.
8134 */
8135 static int
8136 do_autocmd_event(event, pat, nested, cmd, forceit, group)
8137 event_T event;
8138 char_u *pat;
8139 int nested;
8140 char_u *cmd;
8141 int forceit;
8142 int group;
8143 {
8144 AutoPat *ap;
8145 AutoPat **prev_ap;
8146 AutoCmd *ac;
8147 AutoCmd **prev_ac;
8148 int brace_level;
8149 char_u *endpat;
8150 int findgroup;
8151 int allgroups;
8152 int patlen;
8153 int is_buflocal;
8154 int buflocal_nr;
8155 char_u buflocal_pat[25]; /* for "<buffer=X>" */
8156
8157 if (group == AUGROUP_ALL)
8158 findgroup = current_augroup;
8159 else
8160 findgroup = group;
8161 allgroups = (group == AUGROUP_ALL && !forceit && *cmd == NUL);
8162
8163 /*
8164 * Show or delete all patterns for an event.
8165 */
8166 if (*pat == NUL)
8167 {
8168 for (ap = first_autopat[(int)event]; ap != NULL; ap = ap->next)
8169 {
8170 if (forceit) /* delete the AutoPat, if it's in the current group */
8171 {
8172 if (ap->group == findgroup)
8173 au_remove_pat(ap);
8174 }
8175 else if (group == AUGROUP_ALL || ap->group == group)
8176 show_autocmd(ap, event);
8177 }
8178 }
8179
8180 /*
8181 * Loop through all the specified patterns.
8182 */
8183 for ( ; *pat; pat = (*endpat == ',' ? endpat + 1 : endpat))
8184 {
8185 /*
8186 * Find end of the pattern.
8187 * Watch out for a comma in braces, like "*.\{obj,o\}".
8188 */
8189 brace_level = 0;
8190 for (endpat = pat; *endpat && (*endpat != ',' || brace_level
8191 || endpat[-1] == '\\'); ++endpat)
8192 {
8193 if (*endpat == '{')
8194 brace_level++;
8195 else if (*endpat == '}')
8196 brace_level--;
8197 }
8198 if (pat == endpat) /* ignore single comma */
8199 continue;
8200 patlen = (int)(endpat - pat);
8201
8202 /*
8203 * detect special <buflocal[=X]> buffer-local patterns
8204 */
8205 is_buflocal = FALSE;
8206 buflocal_nr = 0;
8207
8208 if (patlen >= 7 && STRNCMP(pat, "<buffer", 7) == 0
8209 && pat[patlen - 1] == '>')
8210 {
8211 /* Error will be printed only for addition. printing and removing
8212 * will proceed silently. */
8213 is_buflocal = TRUE;
8214 if (patlen == 8)
8215 buflocal_nr = curbuf->b_fnum;
8216 else if (patlen > 9 && pat[7] == '=')
8217 {
8218 /* <buffer=abuf> */
8219 if (patlen == 13 && STRNICMP(pat, "<buffer=abuf>", 13))
8220 buflocal_nr = autocmd_bufnr;
8221 /* <buffer=123> */
8222 else if (skipdigits(pat + 8) == pat + patlen - 1)
8223 buflocal_nr = atoi((char *)pat + 8);
8224 }
8225 }
8226
8227 if (is_buflocal)
8228 {
8229 /* normalize pat into standard "<buffer>#N" form */
8230 sprintf((char *)buflocal_pat, "<buffer=%d>", buflocal_nr);
8231 pat = buflocal_pat; /* can modify pat and patlen */
8232 patlen = (int)STRLEN(buflocal_pat); /* but not endpat */
8233 }
8234
8235 /*
8236 * Find AutoPat entries with this pattern.
8237 */
8238 prev_ap = &first_autopat[(int)event];
8239 while ((ap = *prev_ap) != NULL)
8240 {
8241 if (ap->pat != NULL)
8242 {
8243 /* Accept a pattern when:
8244 * - a group was specified and it's that group, or a group was
8245 * not specified and it's the current group, or a group was
8246 * not specified and we are listing
8247 * - the length of the pattern matches
8248 * - the pattern matches.
8249 * For <buffer[=X]>, this condition works because we normalize
8250 * all buffer-local patterns.
8251 */
8252 if ((allgroups || ap->group == findgroup)
8253 && ap->patlen == patlen
8254 && STRNCMP(pat, ap->pat, patlen) == 0)
8255 {
8256 /*
8257 * Remove existing autocommands.
8258 * If adding any new autocmd's for this AutoPat, don't
8259 * delete the pattern from the autopat list, append to
8260 * this list.
8261 */
8262 if (forceit)
8263 {
8264 if (*cmd != NUL && ap->next == NULL)
8265 {
8266 au_remove_cmds(ap);
8267 break;
8268 }
8269 au_remove_pat(ap);
8270 }
8271
8272 /*
8273 * Show autocmd's for this autopat, or buflocals <buffer=X>
8274 */
8275 else if (*cmd == NUL)
8276 show_autocmd(ap, event);
8277
8278 /*
8279 * Add autocmd to this autopat, if it's the last one.
8280 */
8281 else if (ap->next == NULL)
8282 break;
8283 }
8284 }
8285 prev_ap = &ap->next;
8286 }
8287
8288 /*
8289 * Add a new command.
8290 */
8291 if (*cmd != NUL)
8292 {
8293 /*
8294 * If the pattern we want to add a command to does appear at the
8295 * end of the list (or not is not in the list at all), add the
8296 * pattern at the end of the list.
8297 */
8298 if (ap == NULL)
8299 {
8300 /* refuse to add buffer-local ap if buffer number is invalid */
8301 if (is_buflocal && (buflocal_nr == 0
8302 || buflist_findnr(buflocal_nr) == NULL))
8303 {
8304 EMSGN(_("E680: <buffer=%d>: invalid buffer number "),
8305 buflocal_nr);
8306 return FAIL;
8307 }
8308
8309 ap = (AutoPat *)alloc((unsigned)sizeof(AutoPat));
8310 if (ap == NULL)
8311 return FAIL;
8312 ap->pat = vim_strnsave(pat, patlen);
8313 ap->patlen = patlen;
8314 if (ap->pat == NULL)
8315 {
8316 vim_free(ap);
8317 return FAIL;
8318 }
8319
8320 if (is_buflocal)
8321 {
8322 ap->buflocal_nr = buflocal_nr;
8323 ap->reg_prog = NULL;
8324 }
8325 else
8326 {
8327 char_u *reg_pat;
8328
8329 ap->buflocal_nr = 0;
8330 reg_pat = file_pat_to_reg_pat(pat, endpat,
8331 &ap->allow_dirs, TRUE);
8332 if (reg_pat != NULL)
8333 ap->reg_prog = vim_regcomp(reg_pat, RE_MAGIC);
8334 vim_free(reg_pat);
8335 if (reg_pat == NULL || ap->reg_prog == NULL)
8336 {
8337 vim_free(ap->pat);
8338 vim_free(ap);
8339 return FAIL;
8340 }
8341 }
8342 ap->cmds = NULL;
8343 *prev_ap = ap;
8344 ap->next = NULL;
8345 if (group == AUGROUP_ALL)
8346 ap->group = current_augroup;
8347 else
8348 ap->group = group;
8349 }
8350
8351 /*
8352 * Add the autocmd at the end of the AutoCmd list.
8353 */
8354 prev_ac = &(ap->cmds);
8355 while ((ac = *prev_ac) != NULL)
8356 prev_ac = &ac->next;
8357 ac = (AutoCmd *)alloc((unsigned)sizeof(AutoCmd));
8358 if (ac == NULL)
8359 return FAIL;
8360 ac->cmd = vim_strsave(cmd);
8361 #ifdef FEAT_EVAL
8362 ac->scriptID = current_SID;
8363 #endif
8364 if (ac->cmd == NULL)
8365 {
8366 vim_free(ac);
8367 return FAIL;
8368 }
8369 ac->next = NULL;
8370 *prev_ac = ac;
8371 ac->nested = nested;
8372 }
8373 }
8374
8375 au_cleanup(); /* may really delete removed patterns/commands now */
8376 return OK;
8377 }
8378
8379 /*
8380 * Implementation of ":doautocmd [group] event [fname]".
8381 * Return OK for success, FAIL for failure;
8382 */
8383 int
8384 do_doautocmd(arg, do_msg)
8385 char_u *arg;
8386 int do_msg; /* give message for no matching autocmds? */
8387 {
8388 char_u *fname;
8389 int nothing_done = TRUE;
8390 int group;
8391
8392 /*
8393 * Check for a legal group name. If not, use AUGROUP_ALL.
8394 */
8395 group = au_get_grouparg(&arg);
8396 if (arg == NULL) /* out of memory */
8397 return FAIL;
8398
8399 if (*arg == '*')
8400 {
8401 EMSG(_("E217: Can't execute autocommands for ALL events"));
8402 return FAIL;
8403 }
8404
8405 /*
8406 * Scan over the events.
8407 * If we find an illegal name, return here, don't do anything.
8408 */
8409 fname = find_end_event(arg, group != AUGROUP_ALL);
8410 if (fname == NULL)
8411 return FAIL;
8412
8413 fname = skipwhite(fname);
8414
8415 /*
8416 * Loop over the events.
8417 */
8418 while (*arg && !vim_iswhite(*arg))
8419 if (apply_autocmds_group(event_name2nr(arg, &arg),
8420 fname, NULL, TRUE, group, curbuf, NULL))
8421 nothing_done = FALSE;
8422
8423 if (nothing_done && do_msg)
8424 MSG(_("No matching autocommands"));
8425
8426 #ifdef FEAT_EVAL
8427 return aborting() ? FAIL : OK;
8428 #else
8429 return OK;
8430 #endif
8431 }
8432
8433 /*
8434 * ":doautoall": execute autocommands for each loaded buffer.
8435 */
8436 void
8437 ex_doautoall(eap)
8438 exarg_T *eap;
8439 {
8440 int retval;
8441 aco_save_T aco;
8442 buf_T *buf;
8443
8444 /*
8445 * This is a bit tricky: For some commands curwin->w_buffer needs to be
8446 * equal to curbuf, but for some buffers there may not be a window.
8447 * So we change the buffer for the current window for a moment. This
8448 * gives problems when the autocommands make changes to the list of
8449 * buffers or windows...
8450 */
8451 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
8452 {
8453 if (buf->b_ml.ml_mfp != NULL)
8454 {
8455 /* find a window for this buffer and save some values */
8456 aucmd_prepbuf(&aco, buf);
8457
8458 /* execute the autocommands for this buffer */
8459 retval = do_doautocmd(eap->arg, FALSE);
8460
8461 /* Execute the modeline settings, but don't set window-local
8462 * options if we are using the current window for another buffer. */
8463 do_modelines(curwin == aucmd_win ? OPT_NOWIN : 0);
8464
8465 /* restore the current window */
8466 aucmd_restbuf(&aco);
8467
8468 /* stop if there is some error or buffer was deleted */
8469 if (retval == FAIL || !buf_valid(buf))
8470 break;
8471 }
8472 }
8473
8474 check_cursor(); /* just in case lines got deleted */
8475 }
8476
8477 /*
8478 * Prepare for executing autocommands for (hidden) buffer "buf".
8479 * Search for a visible window containing the current buffer. If there isn't
8480 * one then use "aucmd_win".
8481 * Set "curbuf" and "curwin" to match "buf".
8482 * When FEAT_AUTOCMD is not defined another version is used, see below.
8483 */
8484 void
8485 aucmd_prepbuf(aco, buf)
8486 aco_save_T *aco; /* structure to save values in */
8487 buf_T *buf; /* new curbuf */
8488 {
8489 win_T *win;
8490 #ifdef FEAT_WINDOWS
8491 int save_ea;
8492 #endif
8493
8494 /* Find a window that is for the new buffer */
8495 if (buf == curbuf) /* be quick when buf is curbuf */
8496 win = curwin;
8497 else
8498 #ifdef FEAT_WINDOWS
8499 for (win = firstwin; win != NULL; win = win->w_next)
8500 if (win->w_buffer == buf)
8501 break;
8502 #else
8503 win = NULL;
8504 #endif
8505
8506 /* Allocate "aucmd_win" when needed. If this fails (out of memory) fall
8507 * back to using the current window. */
8508 if (win == NULL && aucmd_win == NULL)
8509 {
8510 win_alloc_aucmd_win();
8511 if (aucmd_win == NULL)
8512 win = curwin;
8513 }
8514 if (win == NULL && aucmd_win_used)
8515 /* Strange recursive autocommand, fall back to using the current
8516 * window. Expect a few side effects... */
8517 win = curwin;
8518
8519 aco->save_curwin = curwin;
8520 aco->save_curbuf = curbuf;
8521 if (win != NULL)
8522 {
8523 /* There is a window for "buf" in the current tab page, make it the
8524 * curwin. This is preferred, it has the least side effects (esp. if
8525 * "buf" is curbuf). */
8526 aco->use_aucmd_win = FALSE;
8527 curwin = win;
8528 }
8529 else
8530 {
8531 /* There is no window for "buf", use "aucmd_win". To minimize the side
8532 * effects, insert it in a the current tab page.
8533 * Anything related to a window (e.g., setting folds) may have
8534 * unexpected results. */
8535 aco->use_aucmd_win = TRUE;
8536 aucmd_win_used = TRUE;
8537 aucmd_win->w_buffer = buf;
8538 ++buf->b_nwindows;
8539 win_init_empty(aucmd_win); /* set cursor and topline to safe values */
8540 vim_free(aucmd_win->w_localdir);
8541 aucmd_win->w_localdir = NULL;
8542
8543 /* Make sure w_localdir and globaldir are NULL to avoid a chdir() in
8544 * win_enter_ext(). */
8545 aucmd_win->w_localdir = NULL;
8546 aco->globaldir = globaldir;
8547 globaldir = NULL;
8548
8549
8550 #ifdef FEAT_WINDOWS
8551 /* Split the current window, put the aucmd_win in the upper half.
8552 * We don't want the BufEnter or WinEnter autocommands. */
8553 block_autocmds();
8554 make_snapshot(SNAP_AUCMD_IDX);
8555 save_ea = p_ea;
8556 p_ea = FALSE;
8557 (void)win_split_ins(0, WSP_TOP, aucmd_win, 0);
8558 (void)win_comp_pos(); /* recompute window positions */
8559 p_ea = save_ea;
8560 unblock_autocmds();
8561 #endif
8562 curwin = aucmd_win;
8563 }
8564 curbuf = buf;
8565 aco->new_curwin = curwin;
8566 aco->new_curbuf = curbuf;
8567 }
8568
8569 /*
8570 * Cleanup after executing autocommands for a (hidden) buffer.
8571 * Restore the window as it was (if possible).
8572 * When FEAT_AUTOCMD is not defined another version is used, see below.
8573 */
8574 void
8575 aucmd_restbuf(aco)
8576 aco_save_T *aco; /* structure holding saved values */
8577 {
8578 #ifdef FEAT_WINDOWS
8579 int dummy;
8580 #endif
8581
8582 if (aco->use_aucmd_win)
8583 {
8584 --curbuf->b_nwindows;
8585 #ifdef FEAT_WINDOWS
8586 /* Find "aucmd_win", it can't be closed, but it may be in another tab
8587 * page. Do not trigger autocommands here. */
8588 block_autocmds();
8589 if (curwin != aucmd_win)
8590 {
8591 tabpage_T *tp;
8592 win_T *wp;
8593
8594 FOR_ALL_TAB_WINDOWS(tp, wp)
8595 {
8596 if (wp == aucmd_win)
8597 {
8598 if (tp != curtab)
8599 goto_tabpage_tp(tp);
8600 win_goto(aucmd_win);
8601 break;
8602 }
8603 }
8604 }
8605
8606 /* Remove the window and frame from the tree of frames. */
8607 (void)winframe_remove(curwin, &dummy, NULL);
8608 win_remove(curwin, NULL);
8609 aucmd_win_used = FALSE;
8610 last_status(FALSE); /* may need to remove last status line */
8611 restore_snapshot(SNAP_AUCMD_IDX, FALSE);
8612 (void)win_comp_pos(); /* recompute window positions */
8613 unblock_autocmds();
8614
8615 if (win_valid(aco->save_curwin))
8616 curwin = aco->save_curwin;
8617 else
8618 /* Hmm, original window disappeared. Just use the first one. */
8619 curwin = firstwin;
8620 # ifdef FEAT_EVAL
8621 vars_clear(&aucmd_win->w_vars.dv_hashtab); /* free all w: variables */
8622 hash_init(&aucmd_win->w_vars.dv_hashtab); /* re-use the hashtab */
8623 # endif
8624 #else
8625 curwin = aco->save_curwin;
8626 #endif
8627 curbuf = curwin->w_buffer;
8628
8629 vim_free(globaldir);
8630 globaldir = aco->globaldir;
8631
8632 /* the buffer contents may have changed */
8633 check_cursor();
8634 if (curwin->w_topline > curbuf->b_ml.ml_line_count)
8635 {
8636 curwin->w_topline = curbuf->b_ml.ml_line_count;
8637 #ifdef FEAT_DIFF
8638 curwin->w_topfill = 0;
8639 #endif
8640 }
8641 #if defined(FEAT_GUI)
8642 /* Hide the scrollbars from the aucmd_win and update. */
8643 gui_mch_enable_scrollbar(&aucmd_win->w_scrollbars[SBAR_LEFT], FALSE);
8644 gui_mch_enable_scrollbar(&aucmd_win->w_scrollbars[SBAR_RIGHT], FALSE);
8645 gui_may_update_scrollbars();
8646 #endif
8647 }
8648 else
8649 {
8650 /* restore curwin */
8651 #ifdef FEAT_WINDOWS
8652 if (win_valid(aco->save_curwin))
8653 #endif
8654 {
8655 /* Restore the buffer which was previously edited by curwin, if
8656 * it was changed, we are still the same window and the buffer is
8657 * valid. */
8658 if (curwin == aco->new_curwin
8659 && curbuf != aco->new_curbuf
8660 && buf_valid(aco->new_curbuf)
8661 && aco->new_curbuf->b_ml.ml_mfp != NULL)
8662 {
8663 --curbuf->b_nwindows;
8664 curbuf = aco->new_curbuf;
8665 curwin->w_buffer = curbuf;
8666 ++curbuf->b_nwindows;
8667 }
8668
8669 curwin = aco->save_curwin;
8670 curbuf = curwin->w_buffer;
8671 }
8672 }
8673 }
8674
8675 static int autocmd_nested = FALSE;
8676
8677 /*
8678 * Execute autocommands for "event" and file name "fname".
8679 * Return TRUE if some commands were executed.
8680 */
8681 int
8682 apply_autocmds(event, fname, fname_io, force, buf)
8683 event_T event;
8684 char_u *fname; /* NULL or empty means use actual file name */
8685 char_u *fname_io; /* fname to use for <afile> on cmdline */
8686 int force; /* when TRUE, ignore autocmd_busy */
8687 buf_T *buf; /* buffer for <abuf> */
8688 {
8689 return apply_autocmds_group(event, fname, fname_io, force,
8690 AUGROUP_ALL, buf, NULL);
8691 }
8692
8693 /*
8694 * Like apply_autocmds(), but with extra "eap" argument. This takes care of
8695 * setting v:filearg.
8696 */
8697 static int
8698 apply_autocmds_exarg(event, fname, fname_io, force, buf, eap)
8699 event_T event;
8700 char_u *fname;
8701 char_u *fname_io;
8702 int force;
8703 buf_T *buf;
8704 exarg_T *eap;
8705 {
8706 return apply_autocmds_group(event, fname, fname_io, force,
8707 AUGROUP_ALL, buf, eap);
8708 }
8709
8710 /*
8711 * Like apply_autocmds(), but handles the caller's retval. If the script
8712 * processing is being aborted or if retval is FAIL when inside a try
8713 * conditional, no autocommands are executed. If otherwise the autocommands
8714 * cause the script to be aborted, retval is set to FAIL.
8715 */
8716 int
8717 apply_autocmds_retval(event, fname, fname_io, force, buf, retval)
8718 event_T event;
8719 char_u *fname; /* NULL or empty means use actual file name */
8720 char_u *fname_io; /* fname to use for <afile> on cmdline */
8721 int force; /* when TRUE, ignore autocmd_busy */
8722 buf_T *buf; /* buffer for <abuf> */
8723 int *retval; /* pointer to caller's retval */
8724 {
8725 int did_cmd;
8726
8727 #ifdef FEAT_EVAL
8728 if (should_abort(*retval))
8729 return FALSE;
8730 #endif
8731
8732 did_cmd = apply_autocmds_group(event, fname, fname_io, force,
8733 AUGROUP_ALL, buf, NULL);
8734 if (did_cmd
8735 #ifdef FEAT_EVAL
8736 && aborting()
8737 #endif
8738 )
8739 *retval = FAIL;
8740 return did_cmd;
8741 }
8742
8743 /*
8744 * Return TRUE when there is a CursorHold autocommand defined.
8745 */
8746 int
8747 has_cursorhold()
8748 {
8749 return (first_autopat[(int)(get_real_state() == NORMAL_BUSY
8750 ? EVENT_CURSORHOLD : EVENT_CURSORHOLDI)] != NULL);
8751 }
8752
8753 /*
8754 * Return TRUE if the CursorHold event can be triggered.
8755 */
8756 int
8757 trigger_cursorhold()
8758 {
8759 int state;
8760
8761 if (!did_cursorhold && has_cursorhold() && !Recording
8762 #ifdef FEAT_INS_EXPAND
8763 && !ins_compl_active()
8764 #endif
8765 )
8766 {
8767 state = get_real_state();
8768 if (state == NORMAL_BUSY || (state & INSERT) != 0)
8769 return TRUE;
8770 }
8771 return FALSE;
8772 }
8773
8774 /*
8775 * Return TRUE when there is a CursorMoved autocommand defined.
8776 */
8777 int
8778 has_cursormoved()
8779 {
8780 return (first_autopat[(int)EVENT_CURSORMOVED] != NULL);
8781 }
8782
8783 /*
8784 * Return TRUE when there is a CursorMovedI autocommand defined.
8785 */
8786 int
8787 has_cursormovedI()
8788 {
8789 return (first_autopat[(int)EVENT_CURSORMOVEDI] != NULL);
8790 }
8791
8792 static int
8793 apply_autocmds_group(event, fname, fname_io, force, group, buf, eap)
8794 event_T event;
8795 char_u *fname; /* NULL or empty means use actual file name */
8796 char_u *fname_io; /* fname to use for <afile> on cmdline, NULL means
8797 use fname */
8798 int force; /* when TRUE, ignore autocmd_busy */
8799 int group; /* group ID, or AUGROUP_ALL */
8800 buf_T *buf; /* buffer for <abuf> */
8801 exarg_T *eap; /* command arguments */
8802 {
8803 char_u *sfname = NULL; /* short file name */
8804 char_u *tail;
8805 int save_changed;
8806 buf_T *old_curbuf;
8807 int retval = FALSE;
8808 char_u *save_sourcing_name;
8809 linenr_T save_sourcing_lnum;
8810 char_u *save_autocmd_fname;
8811 int save_autocmd_fname_full;
8812 int save_autocmd_bufnr;
8813 char_u *save_autocmd_match;
8814 int save_autocmd_busy;
8815 int save_autocmd_nested;
8816 static int nesting = 0;
8817 AutoPatCmd patcmd;
8818 AutoPat *ap;
8819 #ifdef FEAT_EVAL
8820 scid_T save_current_SID;
8821 void *save_funccalp;
8822 char_u *save_cmdarg;
8823 long save_cmdbang;
8824 #endif
8825 static int filechangeshell_busy = FALSE;
8826 #ifdef FEAT_PROFILE
8827 proftime_T wait_time;
8828 #endif
8829
8830 /*
8831 * Quickly return if there are no autocommands for this event or
8832 * autocommands are blocked.
8833 */
8834 if (first_autopat[(int)event] == NULL || autocmd_blocked > 0)
8835 goto BYPASS_AU;
8836
8837 /*
8838 * When autocommands are busy, new autocommands are only executed when
8839 * explicitly enabled with the "nested" flag.
8840 */
8841 if (autocmd_busy && !(force || autocmd_nested))
8842 goto BYPASS_AU;
8843
8844 #ifdef FEAT_EVAL
8845 /*
8846 * Quickly return when immediately aborting on error, or when an interrupt
8847 * occurred or an exception was thrown but not caught.
8848 */
8849 if (aborting())
8850 goto BYPASS_AU;
8851 #endif
8852
8853 /*
8854 * FileChangedShell never nests, because it can create an endless loop.
8855 */
8856 if (filechangeshell_busy && (event == EVENT_FILECHANGEDSHELL
8857 || event == EVENT_FILECHANGEDSHELLPOST))
8858 goto BYPASS_AU;
8859
8860 /*
8861 * Ignore events in 'eventignore'.
8862 */
8863 if (event_ignored(event))
8864 goto BYPASS_AU;
8865
8866 /*
8867 * Allow nesting of autocommands, but restrict the depth, because it's
8868 * possible to create an endless loop.
8869 */
8870 if (nesting == 10)
8871 {
8872 EMSG(_("E218: autocommand nesting too deep"));
8873 goto BYPASS_AU;
8874 }
8875
8876 /*
8877 * Check if these autocommands are disabled. Used when doing ":all" or
8878 * ":ball".
8879 */
8880 if ( (autocmd_no_enter
8881 && (event == EVENT_WINENTER || event == EVENT_BUFENTER))
8882 || (autocmd_no_leave
8883 && (event == EVENT_WINLEAVE || event == EVENT_BUFLEAVE)))
8884 goto BYPASS_AU;
8885
8886 /*
8887 * Save the autocmd_* variables and info about the current buffer.
8888 */
8889 save_autocmd_fname = autocmd_fname;
8890 save_autocmd_fname_full = autocmd_fname_full;
8891 save_autocmd_bufnr = autocmd_bufnr;
8892 save_autocmd_match = autocmd_match;
8893 save_autocmd_busy = autocmd_busy;
8894 save_autocmd_nested = autocmd_nested;
8895 save_changed = curbuf->b_changed;
8896 old_curbuf = curbuf;
8897
8898 /*
8899 * Set the file name to be used for <afile>.
8900 * Make a copy to avoid that changing a buffer name or directory makes it
8901 * invalid.
8902 */
8903 if (fname_io == NULL)
8904 {
8905 if (fname != NULL && *fname != NUL)
8906 autocmd_fname = fname;
8907 else if (buf != NULL)
8908 autocmd_fname = buf->b_ffname;
8909 else
8910 autocmd_fname = NULL;
8911 }
8912 else
8913 autocmd_fname = fname_io;
8914 if (autocmd_fname != NULL)
8915 autocmd_fname = vim_strsave(autocmd_fname);
8916 autocmd_fname_full = FALSE; /* call FullName_save() later */
8917
8918 /*
8919 * Set the buffer number to be used for <abuf>.
8920 */
8921 if (buf == NULL)
8922 autocmd_bufnr = 0;
8923 else
8924 autocmd_bufnr = buf->b_fnum;
8925
8926 /*
8927 * When the file name is NULL or empty, use the file name of buffer "buf".
8928 * Always use the full path of the file name to match with, in case
8929 * "allow_dirs" is set.
8930 */
8931 if (fname == NULL || *fname == NUL)
8932 {
8933 if (buf == NULL)
8934 fname = NULL;
8935 else
8936 {
8937 #ifdef FEAT_SYN_HL
8938 if (event == EVENT_SYNTAX)
8939 fname = buf->b_p_syn;
8940 else
8941 #endif
8942 if (event == EVENT_FILETYPE)
8943 fname = buf->b_p_ft;
8944 else
8945 {
8946 if (buf->b_sfname != NULL)
8947 sfname = vim_strsave(buf->b_sfname);
8948 fname = buf->b_ffname;
8949 }
8950 }
8951 if (fname == NULL)
8952 fname = (char_u *)"";
8953 fname = vim_strsave(fname); /* make a copy, so we can change it */
8954 }
8955 else
8956 {
8957 sfname = vim_strsave(fname);
8958 /* Don't try expanding FileType, Syntax, FuncUndefined, WindowID or
8959 * QuickFixCmd* */
8960 if (event == EVENT_FILETYPE
8961 || event == EVENT_SYNTAX
8962 || event == EVENT_FUNCUNDEFINED
8963 || event == EVENT_REMOTEREPLY
8964 || event == EVENT_SPELLFILEMISSING
8965 || event == EVENT_QUICKFIXCMDPRE
8966 || event == EVENT_QUICKFIXCMDPOST)
8967 fname = vim_strsave(fname);
8968 else
8969 fname = FullName_save(fname, FALSE);
8970 }
8971 if (fname == NULL) /* out of memory */
8972 {
8973 vim_free(sfname);
8974 retval = FALSE;
8975 goto BYPASS_AU;
8976 }
8977
8978 #ifdef BACKSLASH_IN_FILENAME
8979 /*
8980 * Replace all backslashes with forward slashes. This makes the
8981 * autocommand patterns portable between Unix and MS-DOS.
8982 */
8983 if (sfname != NULL)
8984 forward_slash(sfname);
8985 forward_slash(fname);
8986 #endif
8987
8988 #ifdef VMS
8989 /* remove version for correct match */
8990 if (sfname != NULL)
8991 vms_remove_version(sfname);
8992 vms_remove_version(fname);
8993 #endif
8994
8995 /*
8996 * Set the name to be used for <amatch>.
8997 */
8998 autocmd_match = fname;
8999
9000
9001 /* Don't redraw while doing auto commands. */
9002 ++RedrawingDisabled;
9003 save_sourcing_name = sourcing_name;
9004 sourcing_name = NULL; /* don't free this one */
9005 save_sourcing_lnum = sourcing_lnum;
9006 sourcing_lnum = 0; /* no line number here */
9007
9008 #ifdef FEAT_EVAL
9009 save_current_SID = current_SID;
9010
9011 # ifdef FEAT_PROFILE
9012 if (do_profiling == PROF_YES)
9013 prof_child_enter(&wait_time); /* doesn't count for the caller itself */
9014 # endif
9015
9016 /* Don't use local function variables, if called from a function */
9017 save_funccalp = save_funccal();
9018 #endif
9019
9020 /*
9021 * When starting to execute autocommands, save the search patterns.
9022 */
9023 if (!autocmd_busy)
9024 {
9025 save_search_patterns();
9026 saveRedobuff();
9027 did_filetype = keep_filetype;
9028 }
9029
9030 /*
9031 * Note that we are applying autocmds. Some commands need to know.
9032 */
9033 autocmd_busy = TRUE;
9034 filechangeshell_busy = (event == EVENT_FILECHANGEDSHELL);
9035 ++nesting; /* see matching decrement below */
9036
9037 /* Remember that FileType was triggered. Used for did_filetype(). */
9038 if (event == EVENT_FILETYPE)
9039 did_filetype = TRUE;
9040
9041 tail = gettail(fname);
9042
9043 /* Find first autocommand that matches */
9044 patcmd.curpat = first_autopat[(int)event];
9045 patcmd.nextcmd = NULL;
9046 patcmd.group = group;
9047 patcmd.fname = fname;
9048 patcmd.sfname = sfname;
9049 patcmd.tail = tail;
9050 patcmd.event = event;
9051 patcmd.arg_bufnr = autocmd_bufnr;
9052 patcmd.next = NULL;
9053 auto_next_pat(&patcmd, FALSE);
9054
9055 /* found one, start executing the autocommands */
9056 if (patcmd.curpat != NULL)
9057 {
9058 /* add to active_apc_list */
9059 patcmd.next = active_apc_list;
9060 active_apc_list = &patcmd;
9061
9062 #ifdef FEAT_EVAL
9063 /* set v:cmdarg (only when there is a matching pattern) */
9064 save_cmdbang = get_vim_var_nr(VV_CMDBANG);
9065 if (eap != NULL)
9066 {
9067 save_cmdarg = set_cmdarg(eap, NULL);
9068 set_vim_var_nr(VV_CMDBANG, (long)eap->forceit);
9069 }
9070 else
9071 save_cmdarg = NULL; /* avoid gcc warning */
9072 #endif
9073 retval = TRUE;
9074 /* mark the last pattern, to avoid an endless loop when more patterns
9075 * are added when executing autocommands */
9076 for (ap = patcmd.curpat; ap->next != NULL; ap = ap->next)
9077 ap->last = FALSE;
9078 ap->last = TRUE;
9079 check_lnums(TRUE); /* make sure cursor and topline are valid */
9080 do_cmdline(NULL, getnextac, (void *)&patcmd,
9081 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT);
9082 #ifdef FEAT_EVAL
9083 if (eap != NULL)
9084 {
9085 (void)set_cmdarg(NULL, save_cmdarg);
9086 set_vim_var_nr(VV_CMDBANG, save_cmdbang);
9087 }
9088 #endif
9089 /* delete from active_apc_list */
9090 if (active_apc_list == &patcmd) /* just in case */
9091 active_apc_list = patcmd.next;
9092 }
9093
9094 --RedrawingDisabled;
9095 autocmd_busy = save_autocmd_busy;
9096 filechangeshell_busy = FALSE;
9097 autocmd_nested = save_autocmd_nested;
9098 vim_free(sourcing_name);
9099 sourcing_name = save_sourcing_name;
9100 sourcing_lnum = save_sourcing_lnum;
9101 vim_free(autocmd_fname);
9102 autocmd_fname = save_autocmd_fname;
9103 autocmd_fname_full = save_autocmd_fname_full;
9104 autocmd_bufnr = save_autocmd_bufnr;
9105 autocmd_match = save_autocmd_match;
9106 #ifdef FEAT_EVAL
9107 current_SID = save_current_SID;
9108 restore_funccal(save_funccalp);
9109 # ifdef FEAT_PROFILE
9110 if (do_profiling == PROF_YES)
9111 prof_child_exit(&wait_time);
9112 # endif
9113 #endif
9114 vim_free(fname);
9115 vim_free(sfname);
9116 --nesting; /* see matching increment above */
9117
9118 /*
9119 * When stopping to execute autocommands, restore the search patterns and
9120 * the redo buffer.
9121 */
9122 if (!autocmd_busy)
9123 {
9124 restore_search_patterns();
9125 restoreRedobuff();
9126 did_filetype = FALSE;
9127 }
9128
9129 /*
9130 * Some events don't set or reset the Changed flag.
9131 * Check if still in the same buffer!
9132 */
9133 if (curbuf == old_curbuf
9134 && (event == EVENT_BUFREADPOST
9135 || event == EVENT_BUFWRITEPOST
9136 || event == EVENT_FILEAPPENDPOST
9137 || event == EVENT_VIMLEAVE
9138 || event == EVENT_VIMLEAVEPRE))
9139 {
9140 #ifdef FEAT_TITLE
9141 if (curbuf->b_changed != save_changed)
9142 need_maketitle = TRUE;
9143 #endif
9144 curbuf->b_changed = save_changed;
9145 }
9146
9147 au_cleanup(); /* may really delete removed patterns/commands now */
9148
9149 BYPASS_AU:
9150 /* When wiping out a buffer make sure all its buffer-local autocommands
9151 * are deleted. */
9152 if (event == EVENT_BUFWIPEOUT && buf != NULL)
9153 aubuflocal_remove(buf);
9154
9155 return retval;
9156 }
9157
9158 # ifdef FEAT_EVAL
9159 static char_u *old_termresponse = NULL;
9160 # endif
9161
9162 /*
9163 * Block triggering autocommands until unblock_autocmd() is called.
9164 * Can be used recursively, so long as it's symmetric.
9165 */
9166 void
9167 block_autocmds()
9168 {
9169 # ifdef FEAT_EVAL
9170 /* Remember the value of v:termresponse. */
9171 if (autocmd_blocked == 0)
9172 old_termresponse = get_vim_var_str(VV_TERMRESPONSE);
9173 # endif
9174 ++autocmd_blocked;
9175 }
9176
9177 void
9178 unblock_autocmds()
9179 {
9180 --autocmd_blocked;
9181
9182 # ifdef FEAT_EVAL
9183 /* When v:termresponse was set while autocommands were blocked, trigger
9184 * the autocommands now. Esp. useful when executing a shell command
9185 * during startup (vimdiff). */
9186 if (autocmd_blocked == 0
9187 && get_vim_var_str(VV_TERMRESPONSE) != old_termresponse)
9188 apply_autocmds(EVENT_TERMRESPONSE, NULL, NULL, FALSE, curbuf);
9189 # endif
9190 }
9191
9192 /*
9193 * Find next autocommand pattern that matches.
9194 */
9195 static void
9196 auto_next_pat(apc, stop_at_last)
9197 AutoPatCmd *apc;
9198 int stop_at_last; /* stop when 'last' flag is set */
9199 {
9200 AutoPat *ap;
9201 AutoCmd *cp;
9202 char_u *name;
9203 char *s;
9204
9205 vim_free(sourcing_name);
9206 sourcing_name = NULL;
9207
9208 for (ap = apc->curpat; ap != NULL && !got_int; ap = ap->next)
9209 {
9210 apc->curpat = NULL;
9211
9212 /* Only use a pattern when it has not been removed, has commands and
9213 * the group matches. For buffer-local autocommands only check the
9214 * buffer number. */
9215 if (ap->pat != NULL && ap->cmds != NULL
9216 && (apc->group == AUGROUP_ALL || apc->group == ap->group))
9217 {
9218 /* execution-condition */
9219 if (ap->buflocal_nr == 0
9220 ? (match_file_pat(NULL, ap->reg_prog, apc->fname,
9221 apc->sfname, apc->tail, ap->allow_dirs))
9222 : ap->buflocal_nr == apc->arg_bufnr)
9223 {
9224 name = event_nr2name(apc->event);
9225 s = _("%s Auto commands for \"%s\"");
9226 sourcing_name = alloc((unsigned)(STRLEN(s)
9227 + STRLEN(name) + ap->patlen + 1));
9228 if (sourcing_name != NULL)
9229 {
9230 sprintf((char *)sourcing_name, s,
9231 (char *)name, (char *)ap->pat);
9232 if (p_verbose >= 8)
9233 {
9234 verbose_enter();
9235 smsg((char_u *)_("Executing %s"), sourcing_name);
9236 verbose_leave();
9237 }
9238 }
9239
9240 apc->curpat = ap;
9241 apc->nextcmd = ap->cmds;
9242 /* mark last command */
9243 for (cp = ap->cmds; cp->next != NULL; cp = cp->next)
9244 cp->last = FALSE;
9245 cp->last = TRUE;
9246 }
9247 line_breakcheck();
9248 if (apc->curpat != NULL) /* found a match */
9249 break;
9250 }
9251 if (stop_at_last && ap->last)
9252 break;
9253 }
9254 }
9255
9256 /*
9257 * Get next autocommand command.
9258 * Called by do_cmdline() to get the next line for ":if".
9259 * Returns allocated string, or NULL for end of autocommands.
9260 */
9261 static char_u *
9262 getnextac(c, cookie, indent)
9263 int c UNUSED;
9264 void *cookie;
9265 int indent UNUSED;
9266 {
9267 AutoPatCmd *acp = (AutoPatCmd *)cookie;
9268 char_u *retval;
9269 AutoCmd *ac;
9270
9271 /* Can be called again after returning the last line. */
9272 if (acp->curpat == NULL)
9273 return NULL;
9274
9275 /* repeat until we find an autocommand to execute */
9276 for (;;)
9277 {
9278 /* skip removed commands */
9279 while (acp->nextcmd != NULL && acp->nextcmd->cmd == NULL)
9280 if (acp->nextcmd->last)
9281 acp->nextcmd = NULL;
9282 else
9283 acp->nextcmd = acp->nextcmd->next;
9284
9285 if (acp->nextcmd != NULL)
9286 break;
9287
9288 /* at end of commands, find next pattern that matches */
9289 if (acp->curpat->last)
9290 acp->curpat = NULL;
9291 else
9292 acp->curpat = acp->curpat->next;
9293 if (acp->curpat != NULL)
9294 auto_next_pat(acp, TRUE);
9295 if (acp->curpat == NULL)
9296 return NULL;
9297 }
9298
9299 ac = acp->nextcmd;
9300
9301 if (p_verbose >= 9)
9302 {
9303 verbose_enter_scroll();
9304 smsg((char_u *)_("autocommand %s"), ac->cmd);
9305 msg_puts((char_u *)"\n"); /* don't overwrite this either */
9306 verbose_leave_scroll();
9307 }
9308 retval = vim_strsave(ac->cmd);
9309 autocmd_nested = ac->nested;
9310 #ifdef FEAT_EVAL
9311 current_SID = ac->scriptID;
9312 #endif
9313 if (ac->last)
9314 acp->nextcmd = NULL;
9315 else
9316 acp->nextcmd = ac->next;
9317 return retval;
9318 }
9319
9320 /*
9321 * Return TRUE if there is a matching autocommand for "fname".
9322 * To account for buffer-local autocommands, function needs to know
9323 * in which buffer the file will be opened.
9324 */
9325 int
9326 has_autocmd(event, sfname, buf)
9327 event_T event;
9328 char_u *sfname;
9329 buf_T *buf;
9330 {
9331 AutoPat *ap;
9332 char_u *fname;
9333 char_u *tail = gettail(sfname);
9334 int retval = FALSE;
9335
9336 fname = FullName_save(sfname, FALSE);
9337 if (fname == NULL)
9338 return FALSE;
9339
9340 #ifdef BACKSLASH_IN_FILENAME
9341 /*
9342 * Replace all backslashes with forward slashes. This makes the
9343 * autocommand patterns portable between Unix and MS-DOS.
9344 */
9345 sfname = vim_strsave(sfname);
9346 if (sfname != NULL)
9347 forward_slash(sfname);
9348 forward_slash(fname);
9349 #endif
9350
9351 for (ap = first_autopat[(int)event]; ap != NULL; ap = ap->next)
9352 if (ap->pat != NULL && ap->cmds != NULL
9353 && (ap->buflocal_nr == 0
9354 ? match_file_pat(NULL, ap->reg_prog,
9355 fname, sfname, tail, ap->allow_dirs)
9356 : buf != NULL && ap->buflocal_nr == buf->b_fnum
9357 ))
9358 {
9359 retval = TRUE;
9360 break;
9361 }
9362
9363 vim_free(fname);
9364 #ifdef BACKSLASH_IN_FILENAME
9365 vim_free(sfname);
9366 #endif
9367
9368 return retval;
9369 }
9370
9371 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
9372 /*
9373 * Function given to ExpandGeneric() to obtain the list of autocommand group
9374 * names.
9375 */
9376 char_u *
9377 get_augroup_name(xp, idx)
9378 expand_T *xp UNUSED;
9379 int idx;
9380 {
9381 if (idx == augroups.ga_len) /* add "END" add the end */
9382 return (char_u *)"END";
9383 if (idx >= augroups.ga_len) /* end of list */
9384 return NULL;
9385 if (AUGROUP_NAME(idx) == NULL) /* skip deleted entries */
9386 return (char_u *)"";
9387 return AUGROUP_NAME(idx); /* return a name */
9388 }
9389
9390 static int include_groups = FALSE;
9391
9392 char_u *
9393 set_context_in_autocmd(xp, arg, doautocmd)
9394 expand_T *xp;
9395 char_u *arg;
9396 int doautocmd; /* TRUE for :doauto*, FALSE for :autocmd */
9397 {
9398 char_u *p;
9399 int group;
9400
9401 /* check for a group name, skip it if present */
9402 include_groups = FALSE;
9403 p = arg;
9404 group = au_get_grouparg(&arg);
9405 if (group == AUGROUP_ERROR)
9406 return NULL;
9407 /* If there only is a group name that's what we expand. */
9408 if (*arg == NUL && group != AUGROUP_ALL && !vim_iswhite(arg[-1]))
9409 {
9410 arg = p;
9411 group = AUGROUP_ALL;
9412 }
9413
9414 /* skip over event name */
9415 for (p = arg; *p != NUL && !vim_iswhite(*p); ++p)
9416 if (*p == ',')
9417 arg = p + 1;
9418 if (*p == NUL)
9419 {
9420 if (group == AUGROUP_ALL)
9421 include_groups = TRUE;
9422 xp->xp_context = EXPAND_EVENTS; /* expand event name */
9423 xp->xp_pattern = arg;
9424 return NULL;
9425 }
9426
9427 /* skip over pattern */
9428 arg = skipwhite(p);
9429 while (*arg && (!vim_iswhite(*arg) || arg[-1] == '\\'))
9430 arg++;
9431 if (*arg)
9432 return arg; /* expand (next) command */
9433
9434 if (doautocmd)
9435 xp->xp_context = EXPAND_FILES; /* expand file names */
9436 else
9437 xp->xp_context = EXPAND_NOTHING; /* pattern is not expanded */
9438 return NULL;
9439 }
9440
9441 /*
9442 * Function given to ExpandGeneric() to obtain the list of event names.
9443 */
9444 char_u *
9445 get_event_name(xp, idx)
9446 expand_T *xp UNUSED;
9447 int idx;
9448 {
9449 if (idx < augroups.ga_len) /* First list group names, if wanted */
9450 {
9451 if (!include_groups || AUGROUP_NAME(idx) == NULL)
9452 return (char_u *)""; /* skip deleted entries */
9453 return AUGROUP_NAME(idx); /* return a name */
9454 }
9455 return (char_u *)event_names[idx - augroups.ga_len].name;
9456 }
9457
9458 #endif /* FEAT_CMDL_COMPL */
9459
9460 /*
9461 * Return TRUE if autocmd is supported.
9462 */
9463 int
9464 autocmd_supported(name)
9465 char_u *name;
9466 {
9467 char_u *p;
9468
9469 return (event_name2nr(name, &p) != NUM_EVENTS);
9470 }
9471
9472 /*
9473 * Return TRUE if an autocommand is defined for a group, event and
9474 * pattern: The group can be omitted to accept any group. "event" and "pattern"
9475 * can be NULL to accept any event and pattern. "pattern" can be NULL to accept
9476 * any pattern. Buffer-local patterns <buffer> or <buffer=N> are accepted.
9477 * Used for:
9478 * exists("#Group") or
9479 * exists("#Group#Event") or
9480 * exists("#Group#Event#pat") or
9481 * exists("#Event") or
9482 * exists("#Event#pat")
9483 */
9484 int
9485 au_exists(arg)
9486 char_u *arg;
9487 {
9488 char_u *arg_save;
9489 char_u *pattern = NULL;
9490 char_u *event_name;
9491 char_u *p;
9492 event_T event;
9493 AutoPat *ap;
9494 buf_T *buflocal_buf = NULL;
9495 int group;
9496 int retval = FALSE;
9497
9498 /* Make a copy so that we can change the '#' chars to a NUL. */
9499 arg_save = vim_strsave(arg);
9500 if (arg_save == NULL)
9501 return FALSE;
9502 p = vim_strchr(arg_save, '#');
9503 if (p != NULL)
9504 *p++ = NUL;
9505
9506 /* First, look for an autocmd group name */
9507 group = au_find_group(arg_save);
9508 if (group == AUGROUP_ERROR)
9509 {
9510 /* Didn't match a group name, assume the first argument is an event. */
9511 group = AUGROUP_ALL;
9512 event_name = arg_save;
9513 }
9514 else
9515 {
9516 if (p == NULL)
9517 {
9518 /* "Group": group name is present and it's recognized */
9519 retval = TRUE;
9520 goto theend;
9521 }
9522
9523 /* Must be "Group#Event" or "Group#Event#pat". */
9524 event_name = p;
9525 p = vim_strchr(event_name, '#');
9526 if (p != NULL)
9527 *p++ = NUL; /* "Group#Event#pat" */
9528 }
9529
9530 pattern = p; /* "pattern" is NULL when there is no pattern */
9531
9532 /* find the index (enum) for the event name */
9533 event = event_name2nr(event_name, &p);
9534
9535 /* return FALSE if the event name is not recognized */
9536 if (event == NUM_EVENTS)
9537 goto theend;
9538
9539 /* Find the first autocommand for this event.
9540 * If there isn't any, return FALSE;
9541 * If there is one and no pattern given, return TRUE; */
9542 ap = first_autopat[(int)event];
9543 if (ap == NULL)
9544 goto theend;
9545
9546 /* if pattern is "<buffer>", special handling is needed which uses curbuf */
9547 /* for pattern "<buffer=N>, fnamecmp() will work fine */
9548 if (pattern != NULL && STRICMP(pattern, "<buffer>") == 0)
9549 buflocal_buf = curbuf;
9550
9551 /* Check if there is an autocommand with the given pattern. */
9552 for ( ; ap != NULL; ap = ap->next)
9553 /* only use a pattern when it has not been removed and has commands. */
9554 /* For buffer-local autocommands, fnamecmp() works fine. */
9555 if (ap->pat != NULL && ap->cmds != NULL
9556 && (group == AUGROUP_ALL || ap->group == group)
9557 && (pattern == NULL
9558 || (buflocal_buf == NULL
9559 ? fnamecmp(ap->pat, pattern) == 0
9560 : ap->buflocal_nr == buflocal_buf->b_fnum)))
9561 {
9562 retval = TRUE;
9563 break;
9564 }
9565
9566 theend:
9567 vim_free(arg_save);
9568 return retval;
9569 }
9570
9571 #else /* FEAT_AUTOCMD */
9572
9573 /*
9574 * Prepare for executing commands for (hidden) buffer "buf".
9575 * This is the non-autocommand version, it simply saves "curbuf" and sets
9576 * "curbuf" and "curwin" to match "buf".
9577 */
9578 void
9579 aucmd_prepbuf(aco, buf)
9580 aco_save_T *aco; /* structure to save values in */
9581 buf_T *buf; /* new curbuf */
9582 {
9583 aco->save_curbuf = curbuf;
9584 --curbuf->b_nwindows;
9585 curbuf = buf;
9586 curwin->w_buffer = buf;
9587 ++curbuf->b_nwindows;
9588 }
9589
9590 /*
9591 * Restore after executing commands for a (hidden) buffer.
9592 * This is the non-autocommand version.
9593 */
9594 void
9595 aucmd_restbuf(aco)
9596 aco_save_T *aco; /* structure holding saved values */
9597 {
9598 --curbuf->b_nwindows;
9599 curbuf = aco->save_curbuf;
9600 curwin->w_buffer = curbuf;
9601 ++curbuf->b_nwindows;
9602 }
9603
9604 #endif /* FEAT_AUTOCMD */
9605
9606
9607 #if defined(FEAT_AUTOCMD) || defined(FEAT_WILDIGN) || defined(PROTO)
9608 /*
9609 * Try matching a filename with a "pattern" ("prog" is NULL), or use the
9610 * precompiled regprog "prog" ("pattern" is NULL). That avoids calling
9611 * vim_regcomp() often.
9612 * Used for autocommands and 'wildignore'.
9613 * Returns TRUE if there is a match, FALSE otherwise.
9614 */
9615 int
9616 match_file_pat(pattern, prog, fname, sfname, tail, allow_dirs)
9617 char_u *pattern; /* pattern to match with */
9618 regprog_T *prog; /* pre-compiled regprog or NULL */
9619 char_u *fname; /* full path of file name */
9620 char_u *sfname; /* short file name or NULL */
9621 char_u *tail; /* tail of path */
9622 int allow_dirs; /* allow matching with dir */
9623 {
9624 regmatch_T regmatch;
9625 int result = FALSE;
9626 #ifdef FEAT_OSFILETYPE
9627 int no_pattern = FALSE; /* TRUE if check is filetype only */
9628 char_u *type_start;
9629 char_u c;
9630 int match = FALSE;
9631 #endif
9632
9633 #ifdef CASE_INSENSITIVE_FILENAME
9634 regmatch.rm_ic = TRUE; /* Always ignore case */
9635 #else
9636 regmatch.rm_ic = FALSE; /* Don't ever ignore case */
9637 #endif
9638 #ifdef FEAT_OSFILETYPE
9639 if (*pattern == '<')
9640 {
9641 /* There is a filetype condition specified with this pattern.
9642 * Check the filetype matches first. If not, don't bother with the
9643 * pattern (set regprog to NULL).
9644 * Always use magic for the regexp.
9645 */
9646
9647 for (type_start = pattern + 1; (c = *pattern); pattern++)
9648 {
9649 if ((c == ';' || c == '>') && match == FALSE)
9650 {
9651 *pattern = NUL; /* Terminate the string */
9652 match = mch_check_filetype(fname, type_start);
9653 *pattern = c; /* Restore the terminator */
9654 type_start = pattern + 1;
9655 }
9656 if (c == '>')
9657 break;
9658 }
9659
9660 /* (c should never be NUL, but check anyway) */
9661 if (match == FALSE || c == NUL)
9662 regmatch.regprog = NULL; /* Doesn't match - don't check pat. */
9663 else if (*pattern == NUL)
9664 {
9665 regmatch.regprog = NULL; /* Vim will try to free regprog later */
9666 no_pattern = TRUE; /* Always matches - don't check pat. */
9667 }
9668 else
9669 regmatch.regprog = vim_regcomp(pattern + 1, RE_MAGIC);
9670 }
9671 else
9672 #endif
9673 {
9674 if (prog != NULL)
9675 regmatch.regprog = prog;
9676 else
9677 regmatch.regprog = vim_regcomp(pattern, RE_MAGIC);
9678 }
9679
9680 /*
9681 * Try for a match with the pattern with:
9682 * 1. the full file name, when the pattern has a '/'.
9683 * 2. the short file name, when the pattern has a '/'.
9684 * 3. the tail of the file name, when the pattern has no '/'.
9685 */
9686 if (
9687 #ifdef FEAT_OSFILETYPE
9688 /* If the check is for a filetype only and we don't care
9689 * about the path then skip all the regexp stuff.
9690 */
9691 no_pattern ||
9692 #endif
9693 (regmatch.regprog != NULL
9694 && ((allow_dirs
9695 && (vim_regexec(&regmatch, fname, (colnr_T)0)
9696 || (sfname != NULL
9697 && vim_regexec(&regmatch, sfname, (colnr_T)0))))
9698 || (!allow_dirs && vim_regexec(&regmatch, tail, (colnr_T)0)))))
9699 result = TRUE;
9700
9701 if (prog == NULL)
9702 vim_free(regmatch.regprog);
9703 return result;
9704 }
9705 #endif
9706
9707 #if defined(FEAT_WILDIGN) || defined(PROTO)
9708 /*
9709 * Return TRUE if a file matches with a pattern in "list".
9710 * "list" is a comma-separated list of patterns, like 'wildignore'.
9711 * "sfname" is the short file name or NULL, "ffname" the long file name.
9712 */
9713 int
9714 match_file_list(list, sfname, ffname)
9715 char_u *list;
9716 char_u *sfname;
9717 char_u *ffname;
9718 {
9719 char_u buf[100];
9720 char_u *tail;
9721 char_u *regpat;
9722 char allow_dirs;
9723 int match;
9724 char_u *p;
9725
9726 tail = gettail(sfname);
9727
9728 /* try all patterns in 'wildignore' */
9729 p = list;
9730 while (*p)
9731 {
9732 copy_option_part(&p, buf, 100, ",");
9733 regpat = file_pat_to_reg_pat(buf, NULL, &allow_dirs, FALSE);
9734 if (regpat == NULL)
9735 break;
9736 match = match_file_pat(regpat, NULL, ffname, sfname,
9737 tail, (int)allow_dirs);
9738 vim_free(regpat);
9739 if (match)
9740 return TRUE;
9741 }
9742 return FALSE;
9743 }
9744 #endif
9745
9746 /*
9747 * Convert the given pattern "pat" which has shell style wildcards in it, into
9748 * a regular expression, and return the result in allocated memory. If there
9749 * is a directory path separator to be matched, then TRUE is put in
9750 * allow_dirs, otherwise FALSE is put there -- webb.
9751 * Handle backslashes before special characters, like "\*" and "\ ".
9752 *
9753 * If FEAT_OSFILETYPE defined then pass initial <type> through unchanged. Eg:
9754 * '<html>myfile' becomes '<html>^myfile$' -- leonard.
9755 *
9756 * Returns NULL when out of memory.
9757 */
9758 char_u *
9759 file_pat_to_reg_pat(pat, pat_end, allow_dirs, no_bslash)
9760 char_u *pat;
9761 char_u *pat_end; /* first char after pattern or NULL */
9762 char *allow_dirs; /* Result passed back out in here */
9763 int no_bslash UNUSED; /* Don't use a backward slash as pathsep */
9764 {
9765 int size;
9766 char_u *endp;
9767 char_u *reg_pat;
9768 char_u *p;
9769 int i;
9770 int nested = 0;
9771 int add_dollar = TRUE;
9772 #ifdef FEAT_OSFILETYPE
9773 int check_length = 0;
9774 #endif
9775
9776 if (allow_dirs != NULL)
9777 *allow_dirs = FALSE;
9778 if (pat_end == NULL)
9779 pat_end = pat + STRLEN(pat);
9780
9781 #ifdef FEAT_OSFILETYPE
9782 /* Find out how much of the string is the filetype check */
9783 if (*pat == '<')
9784 {
9785 /* Count chars until the next '>' */
9786 for (p = pat + 1; p < pat_end && *p != '>'; p++)
9787 ;
9788 if (p < pat_end)
9789 {
9790 /* Pattern is of the form <.*>.* */
9791 check_length = p - pat + 1;
9792 if (p + 1 >= pat_end)
9793 {
9794 /* The 'pattern' is a filetype check ONLY */
9795 reg_pat = (char_u *)alloc(check_length + 1);
9796 if (reg_pat != NULL)
9797 {
9798 mch_memmove(reg_pat, pat, (size_t)check_length);
9799 reg_pat[check_length] = NUL;
9800 }
9801 return reg_pat;
9802 }
9803 }
9804 /* else: there was no closing '>' - assume it was a normal pattern */
9805
9806 }
9807 pat += check_length;
9808 size = 2 + check_length;
9809 #else
9810 size = 2; /* '^' at start, '$' at end */
9811 #endif
9812
9813 for (p = pat; p < pat_end; p++)
9814 {
9815 switch (*p)
9816 {
9817 case '*':
9818 case '.':
9819 case ',':
9820 case '{':
9821 case '}':
9822 case '~':
9823 size += 2; /* extra backslash */
9824 break;
9825 #ifdef BACKSLASH_IN_FILENAME
9826 case '\\':
9827 case '/':
9828 size += 4; /* could become "[\/]" */
9829 break;
9830 #endif
9831 default:
9832 size++;
9833 # ifdef FEAT_MBYTE
9834 if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
9835 {
9836 ++p;
9837 ++size;
9838 }
9839 # endif
9840 break;
9841 }
9842 }
9843 reg_pat = alloc(size + 1);
9844 if (reg_pat == NULL)
9845 return NULL;
9846
9847 #ifdef FEAT_OSFILETYPE
9848 /* Copy the type check in to the start. */
9849 if (check_length)
9850 mch_memmove(reg_pat, pat - check_length, (size_t)check_length);
9851 i = check_length;
9852 #else
9853 i = 0;
9854 #endif
9855
9856 if (pat[0] == '*')
9857 while (pat[0] == '*' && pat < pat_end - 1)
9858 pat++;
9859 else
9860 reg_pat[i++] = '^';
9861 endp = pat_end - 1;
9862 if (*endp == '*')
9863 {
9864 while (endp - pat > 0 && *endp == '*')
9865 endp--;
9866 add_dollar = FALSE;
9867 }
9868 for (p = pat; *p && nested >= 0 && p <= endp; p++)
9869 {
9870 switch (*p)
9871 {
9872 case '*':
9873 reg_pat[i++] = '.';
9874 reg_pat[i++] = '*';
9875 while (p[1] == '*') /* "**" matches like "*" */
9876 ++p;
9877 break;
9878 case '.':
9879 #ifdef RISCOS
9880 if (allow_dirs != NULL)
9881 *allow_dirs = TRUE;
9882 /* FALLTHROUGH */
9883 #endif
9884 case '~':
9885 reg_pat[i++] = '\\';
9886 reg_pat[i++] = *p;
9887 break;
9888 case '?':
9889 #ifdef RISCOS
9890 case '#':
9891 #endif
9892 reg_pat[i++] = '.';
9893 break;
9894 case '\\':
9895 if (p[1] == NUL)
9896 break;
9897 #ifdef BACKSLASH_IN_FILENAME
9898 if (!no_bslash)
9899 {
9900 /* translate:
9901 * "\x" to "\\x" e.g., "dir\file"
9902 * "\*" to "\\.*" e.g., "dir\*.c"
9903 * "\?" to "\\." e.g., "dir\??.c"
9904 * "\+" to "\+" e.g., "fileX\+.c"
9905 */
9906 if ((vim_isfilec(p[1]) || p[1] == '*' || p[1] == '?')
9907 && p[1] != '+')
9908 {
9909 reg_pat[i++] = '[';
9910 reg_pat[i++] = '\\';
9911 reg_pat[i++] = '/';
9912 reg_pat[i++] = ']';
9913 if (allow_dirs != NULL)
9914 *allow_dirs = TRUE;
9915 break;
9916 }
9917 }
9918 #endif
9919 if (*++p == '?'
9920 #ifdef BACKSLASH_IN_FILENAME
9921 && no_bslash
9922 #endif
9923 )
9924 reg_pat[i++] = '?';
9925 else
9926 if (*p == ',')
9927 reg_pat[i++] = ',';
9928 else
9929 {
9930 if (allow_dirs != NULL && vim_ispathsep(*p)
9931 #ifdef BACKSLASH_IN_FILENAME
9932 && (!no_bslash || *p != '\\')
9933 #endif
9934 )
9935 *allow_dirs = TRUE;
9936 reg_pat[i++] = '\\';
9937 reg_pat[i++] = *p;
9938 }
9939 break;
9940 #ifdef BACKSLASH_IN_FILENAME
9941 case '/':
9942 reg_pat[i++] = '[';
9943 reg_pat[i++] = '\\';
9944 reg_pat[i++] = '/';
9945 reg_pat[i++] = ']';
9946 if (allow_dirs != NULL)
9947 *allow_dirs = TRUE;
9948 break;
9949 #endif
9950 case '{':
9951 reg_pat[i++] = '\\';
9952 reg_pat[i++] = '(';
9953 nested++;
9954 break;
9955 case '}':
9956 reg_pat[i++] = '\\';
9957 reg_pat[i++] = ')';
9958 --nested;
9959 break;
9960 case ',':
9961 if (nested)
9962 {
9963 reg_pat[i++] = '\\';
9964 reg_pat[i++] = '|';
9965 }
9966 else
9967 reg_pat[i++] = ',';
9968 break;
9969 default:
9970 # ifdef FEAT_MBYTE
9971 if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
9972 reg_pat[i++] = *p++;
9973 else
9974 # endif
9975 if (allow_dirs != NULL && vim_ispathsep(*p))
9976 *allow_dirs = TRUE;
9977 reg_pat[i++] = *p;
9978 break;
9979 }
9980 }
9981 if (add_dollar)
9982 reg_pat[i++] = '$';
9983 reg_pat[i] = NUL;
9984 if (nested != 0)
9985 {
9986 if (nested < 0)
9987 EMSG(_("E219: Missing {."));
9988 else
9989 EMSG(_("E220: Missing }."));
9990 vim_free(reg_pat);
9991 reg_pat = NULL;
9992 }
9993 return reg_pat;
9994 }
Vim for the Mac