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