?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merged from the latest developing branch.
[MacVim.git] / src / fileio.c
bloba28bcd9e65750a714e63351d246fd57578af5819
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 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 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 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 fgets_cr((char *)tbuf, FGETS_SIZE, fp);
6034 #else
6035 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
6110 /*
6111 * When the names are identical, there is nothing to do.
6112 */
6113 if (fnamecmp(from, to) == 0)
6114 return 0;
6115
6116 /*
6117 * Fail if the "from" file doesn't exist. Avoids that "to" is deleted.
6118 */
6119 if (mch_stat((char *)from, &st) < 0)
6120 return -1;
6121
6122 /*
6123 * Delete the "to" file, this is required on some systems to make the
6124 * mch_rename() work, on other systems it makes sure that we don't have
6125 * two files when the mch_rename() fails.
6126 */
6127
6128 #ifdef AMIGA
6129 /*
6130 * With MSDOS-compatible filesystems (crossdos, messydos) it is possible
6131 * that the name of the "to" file is the same as the "from" file, even
6132 * though the names are different. To avoid the chance of accidentally
6133 * deleting the "from" file (horror!) we lock it during the remove.
6134 *
6135 * When used for making a backup before writing the file: This should not
6136 * happen with ":w", because startscript() should detect this problem and
6137 * set buf->b_shortname, causing modname() to return a correct ".bak" file
6138 * name. This problem does exist with ":w filename", but then the
6139 * original file will be somewhere else so the backup isn't really
6140 * important. If autoscripting is off the rename may fail.
6141 */
6142 flock = Lock((UBYTE *)from, (long)ACCESS_READ);
6143 #endif
6144 mch_remove(to);
6145 #ifdef AMIGA
6146 if (flock)
6147 UnLock(flock);
6148 #endif
6149
6150 /*
6151 * First try a normal rename, return if it works.
6152 */
6153 if (mch_rename((char *)from, (char *)to) == 0)
6154 return 0;
6155
6156 /*
6157 * Rename() failed, try copying the file.
6158 */
6159 perm = mch_getperm(from);
6160 #ifdef HAVE_ACL
6161 /* For systems that support ACL: get the ACL from the original file. */
6162 acl = mch_get_acl(from);
6163 #endif
6164 fd_in = mch_open((char *)from, O_RDONLY|O_EXTRA, 0);
6165 if (fd_in == -1)
6166 {
6167 #ifdef HAVE_ACL
6168 mch_free_acl(acl);
6169 #endif
6170 return -1;
6171 }
6172
6173 /* Create the new file with same permissions as the original. */
6174 fd_out = mch_open((char *)to,
6175 O_CREAT|O_EXCL|O_WRONLY|O_EXTRA|O_NOFOLLOW, (int)perm);
6176 if (fd_out == -1)
6177 {
6178 close(fd_in);
6179 #ifdef HAVE_ACL
6180 mch_free_acl(acl);
6181 #endif
6182 return -1;
6183 }
6184
6185 buffer = (char *)alloc(BUFSIZE);
6186 if (buffer == NULL)
6187 {
6188 close(fd_out);
6189 close(fd_in);
6190 #ifdef HAVE_ACL
6191 mch_free_acl(acl);
6192 #endif
6193 return -1;
6194 }
6195
6196 while ((n = vim_read(fd_in, buffer, BUFSIZE)) > 0)
6197 if (vim_write(fd_out, buffer, n) != n)
6198 {
6199 errmsg = _("E208: Error writing to \"%s\"");
6200 break;
6201 }
6202
6203 vim_free(buffer);
6204 close(fd_in);
6205 if (close(fd_out) < 0)
6206 errmsg = _("E209: Error closing \"%s\"");
6207 if (n < 0)
6208 {
6209 errmsg = _("E210: Error reading \"%s\"");
6210 to = from;
6211 }
6212 #ifndef UNIX /* for Unix mch_open() already set the permission */
6213 mch_setperm(to, perm);
6214 #endif
6215 #ifdef HAVE_ACL
6216 mch_set_acl(to, acl);
6217 mch_free_acl(acl);
6218 #endif
6219 if (errmsg != NULL)
6220 {
6221 EMSG2(errmsg, to);
6222 return -1;
6223 }
6224 mch_remove(from);
6225 return 0;
6226 }
6227
6228 static int already_warned = FALSE;
6229
6230 /*
6231 * Check if any not hidden buffer has been changed.
6232 * Postpone the check if there are characters in the stuff buffer, a global
6233 * command is being executed, a mapping is being executed or an autocommand is
6234 * busy.
6235 * Returns TRUE if some message was written (screen should be redrawn and
6236 * cursor positioned).
6237 */
6238 int
6239 check_timestamps(focus)
6240 int focus; /* called for GUI focus event */
6241 {
6242 buf_T *buf;
6243 int didit = 0;
6244 int n;
6245
6246 /* Don't check timestamps while system() or another low-level function may
6247 * cause us to lose and gain focus. */
6248 if (no_check_timestamps > 0)
6249 return FALSE;
6250
6251 /* Avoid doing a check twice. The OK/Reload dialog can cause a focus
6252 * event and we would keep on checking if the file is steadily growing.
6253 * Do check again after typing something. */
6254 if (focus && did_check_timestamps)
6255 {
6256 need_check_timestamps = TRUE;
6257 return FALSE;
6258 }
6259
6260 if (!stuff_empty() || global_busy || !typebuf_typed()
6261 #ifdef FEAT_AUTOCMD
6262 || autocmd_busy || curbuf_lock > 0
6263 #endif
6264 )
6265 need_check_timestamps = TRUE; /* check later */
6266 else
6267 {
6268 ++no_wait_return;
6269 did_check_timestamps = TRUE;
6270 already_warned = FALSE;
6271 for (buf = firstbuf; buf != NULL; )
6272 {
6273 /* Only check buffers in a window. */
6274 if (buf->b_nwindows > 0)
6275 {
6276 n = buf_check_timestamp(buf, focus);
6277 if (didit < n)
6278 didit = n;
6279 if (n > 0 && !buf_valid(buf))
6280 {
6281 /* Autocommands have removed the buffer, start at the
6282 * first one again. */
6283 buf = firstbuf;
6284 continue;
6285 }
6286 }
6287 buf = buf->b_next;
6288 }
6289 --no_wait_return;
6290 need_check_timestamps = FALSE;
6291 if (need_wait_return && didit == 2)
6292 {
6293 /* make sure msg isn't overwritten */
6294 msg_puts((char_u *)"\n");
6295 out_flush();
6296 }
6297 }
6298 return didit;
6299 }
6300
6301 /*
6302 * Move all the lines from buffer "frombuf" to buffer "tobuf".
6303 * Return OK or FAIL. When FAIL "tobuf" is incomplete and/or "frombuf" is not
6304 * empty.
6305 */
6306 static int
6307 move_lines(frombuf, tobuf)
6308 buf_T *frombuf;
6309 buf_T *tobuf;
6310 {
6311 buf_T *tbuf = curbuf;
6312 int retval = OK;
6313 linenr_T lnum;
6314 char_u *p;
6315
6316 /* Copy the lines in "frombuf" to "tobuf". */
6317 curbuf = tobuf;
6318 for (lnum = 1; lnum <= frombuf->b_ml.ml_line_count; ++lnum)
6319 {
6320 p = vim_strsave(ml_get_buf(frombuf, lnum, FALSE));
6321 if (p == NULL || ml_append(lnum - 1, p, 0, FALSE) == FAIL)
6322 {
6323 vim_free(p);
6324 retval = FAIL;
6325 break;
6326 }
6327 vim_free(p);
6328 }
6329
6330 /* Delete all the lines in "frombuf". */
6331 if (retval != FAIL)
6332 {
6333 curbuf = frombuf;
6334 for (lnum = curbuf->b_ml.ml_line_count; lnum > 0; --lnum)
6335 if (ml_delete(lnum, FALSE) == FAIL)
6336 {
6337 /* Oops! We could try putting back the saved lines, but that
6338 * might fail again... */
6339 retval = FAIL;
6340 break;
6341 }
6342 }
6343
6344 curbuf = tbuf;
6345 return retval;
6346 }
6347
6348 /*
6349 * Check if buffer "buf" has been changed.
6350 * Also check if the file for a new buffer unexpectedly appeared.
6351 * return 1 if a changed buffer was found.
6352 * return 2 if a message has been displayed.
6353 * return 0 otherwise.
6354 */
6355 /*ARGSUSED*/
6356 int
6357 buf_check_timestamp(buf, focus)
6358 buf_T *buf;
6359 int focus; /* called for GUI focus event */
6360 {
6361 struct stat st;
6362 int stat_res;
6363 int retval = 0;
6364 char_u *path;
6365 char_u *tbuf;
6366 char *mesg = NULL;
6367 char *mesg2 = "";
6368 int helpmesg = FALSE;
6369 int reload = FALSE;
6370 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6371 int can_reload = FALSE;
6372 #endif
6373 size_t orig_size = buf->b_orig_size;
6374 int orig_mode = buf->b_orig_mode;
6375 #ifdef FEAT_GUI
6376 int save_mouse_correct = need_mouse_correct;
6377 #endif
6378 #ifdef FEAT_AUTOCMD
6379 static int busy = FALSE;
6380 int n;
6381 char_u *s;
6382 #endif
6383 char *reason;
6384
6385 /* If there is no file name, the buffer is not loaded, 'buftype' is
6386 * set, we are in the middle of a save or being called recursively: ignore
6387 * this buffer. */
6388 if (buf->b_ffname == NULL
6389 || buf->b_ml.ml_mfp == NULL
6390 #if defined(FEAT_QUICKFIX)
6391 || *buf->b_p_bt != NUL
6392 #endif
6393 || buf->b_saving
6394 #ifdef FEAT_AUTOCMD
6395 || busy
6396 #endif
6397 #ifdef FEAT_NETBEANS_INTG
6398 || isNetbeansBuffer(buf)
6399 #endif
6400 )
6401 return 0;
6402
6403 if ( !(buf->b_flags & BF_NOTEDITED)
6404 && buf->b_mtime != 0
6405 && ((stat_res = mch_stat((char *)buf->b_ffname, &st)) < 0
6406 || time_differs((long)st.st_mtime, buf->b_mtime)
6407 #ifdef HAVE_ST_MODE
6408 || (int)st.st_mode != buf->b_orig_mode
6409 #else
6410 || mch_getperm(buf->b_ffname) != buf->b_orig_mode
6411 #endif
6412 ))
6413 {
6414 retval = 1;
6415
6416 /* set b_mtime to stop further warnings (e.g., when executing
6417 * FileChangedShell autocmd) */
6418 if (stat_res < 0)
6419 {
6420 buf->b_mtime = 0;
6421 buf->b_orig_size = 0;
6422 buf->b_orig_mode = 0;
6423 }
6424 else
6425 buf_store_time(buf, &st, buf->b_ffname);
6426
6427 /* Don't do anything for a directory. Might contain the file
6428 * explorer. */
6429 if (mch_isdir(buf->b_fname))
6430 ;
6431
6432 /*
6433 * If 'autoread' is set, the buffer has no changes and the file still
6434 * exists, reload the buffer. Use the buffer-local option value if it
6435 * was set, the global option value otherwise.
6436 */
6437 else if ((buf->b_p_ar >= 0 ? buf->b_p_ar : p_ar)
6438 && !bufIsChanged(buf) && stat_res >= 0)
6439 reload = TRUE;
6440 else
6441 {
6442 if (stat_res < 0)
6443 reason = "deleted";
6444 else if (bufIsChanged(buf))
6445 reason = "conflict";
6446 else if (orig_size != buf->b_orig_size || buf_contents_changed(buf))
6447 reason = "changed";
6448 else if (orig_mode != buf->b_orig_mode)
6449 reason = "mode";
6450 else
6451 reason = "time";
6452
6453 #ifdef FEAT_AUTOCMD
6454 /*
6455 * Only give the warning if there are no FileChangedShell
6456 * autocommands.
6457 * Avoid being called recursively by setting "busy".
6458 */
6459 busy = TRUE;
6460 # ifdef FEAT_EVAL
6461 set_vim_var_string(VV_FCS_REASON, (char_u *)reason, -1);
6462 set_vim_var_string(VV_FCS_CHOICE, (char_u *)"", -1);
6463 # endif
6464 n = apply_autocmds(EVENT_FILECHANGEDSHELL,
6465 buf->b_fname, buf->b_fname, FALSE, buf);
6466 busy = FALSE;
6467 if (n)
6468 {
6469 if (!buf_valid(buf))
6470 EMSG(_("E246: FileChangedShell autocommand deleted buffer"));
6471 # ifdef FEAT_EVAL
6472 s = get_vim_var_str(VV_FCS_CHOICE);
6473 if (STRCMP(s, "reload") == 0 && *reason != 'd')
6474 reload = TRUE;
6475 else if (STRCMP(s, "ask") == 0)
6476 n = FALSE;
6477 else
6478 # endif
6479 return 2;
6480 }
6481 if (!n)
6482 #endif
6483 {
6484 if (*reason == 'd')
6485 mesg = _("E211: File \"%s\" no longer available");
6486 else
6487 {
6488 helpmesg = TRUE;
6489 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6490 can_reload = TRUE;
6491 #endif
6492 /*
6493 * Check if the file contents really changed to avoid
6494 * giving a warning when only the timestamp was set (e.g.,
6495 * checked out of CVS). Always warn when the buffer was
6496 * changed.
6497 */
6498 if (reason[2] == 'n')
6499 {
6500 mesg = _("W12: Warning: File \"%s\" has changed and the buffer was changed in Vim as well");
6501 mesg2 = _("See \":help W12\" for more info.");
6502 }
6503 else if (reason[1] == 'h')
6504 {
6505 mesg = _("W11: Warning: File \"%s\" has changed since editing started");
6506 mesg2 = _("See \":help W11\" for more info.");
6507 }
6508 else if (*reason == 'm')
6509 {
6510 mesg = _("W16: Warning: Mode of file \"%s\" has changed since editing started");
6511 mesg2 = _("See \":help W16\" for more info.");
6512 }
6513 /* Else: only timestamp changed, ignored */
6514 }
6515 }
6516 }
6517
6518 }
6519 else if ((buf->b_flags & BF_NEW) && !(buf->b_flags & BF_NEW_W)
6520 && vim_fexists(buf->b_ffname))
6521 {
6522 retval = 1;
6523 mesg = _("W13: Warning: File \"%s\" has been created after editing started");
6524 buf->b_flags |= BF_NEW_W;
6525 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6526 can_reload = TRUE;
6527 #endif
6528 }
6529
6530 if (mesg != NULL)
6531 {
6532 path = home_replace_save(buf, buf->b_fname);
6533 if (path != NULL)
6534 {
6535 if (!helpmesg)
6536 mesg2 = "";
6537 tbuf = alloc((unsigned)(STRLEN(path) + STRLEN(mesg)
6538 + STRLEN(mesg2) + 2));
6539 sprintf((char *)tbuf, mesg, path);
6540 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6541 if (can_reload)
6542 {
6543 if (*mesg2 != NUL)
6544 {
6545 STRCAT(tbuf, "\n");
6546 STRCAT(tbuf, mesg2);
6547 }
6548 if (do_dialog(VIM_WARNING, (char_u *)_("Warning"), tbuf,
6549 (char_u *)_("&OK\n&Load File"), 1, NULL) == 2)
6550 reload = TRUE;
6551 }
6552 else
6553 #endif
6554 if (State > NORMAL_BUSY || (State & CMDLINE) || already_warned)
6555 {
6556 if (*mesg2 != NUL)
6557 {
6558 STRCAT(tbuf, "; ");
6559 STRCAT(tbuf, mesg2);
6560 }
6561 EMSG(tbuf);
6562 retval = 2;
6563 }
6564 else
6565 {
6566 # ifdef FEAT_AUTOCMD
6567 if (!autocmd_busy)
6568 # endif
6569 {
6570 msg_start();
6571 msg_puts_attr(tbuf, hl_attr(HLF_E) + MSG_HIST);
6572 if (*mesg2 != NUL)
6573 msg_puts_attr((char_u *)mesg2,
6574 hl_attr(HLF_W) + MSG_HIST);
6575 msg_clr_eos();
6576 (void)msg_end();
6577 if (emsg_silent == 0)
6578 {
6579 out_flush();
6580 # ifdef FEAT_GUI
6581 if (!focus)
6582 # endif
6583 /* give the user some time to think about it */
6584 ui_delay(1000L, TRUE);
6585
6586 /* don't redraw and erase the message */
6587 redraw_cmdline = FALSE;
6588 }
6589 }
6590 already_warned = TRUE;
6591 }
6592
6593 vim_free(path);
6594 vim_free(tbuf);
6595 }
6596 }
6597
6598 if (reload)
6599 /* Reload the buffer. */
6600 buf_reload(buf, orig_mode);
6601
6602 #ifdef FEAT_AUTOCMD
6603 /* Trigger FileChangedShell when the file was changed in any way. */
6604 if (buf_valid(buf) && retval != 0)
6605 (void)apply_autocmds(EVENT_FILECHANGEDSHELLPOST,
6606 buf->b_fname, buf->b_fname, FALSE, buf);
6607 #endif
6608 #ifdef FEAT_GUI
6609 /* restore this in case an autocommand has set it; it would break
6610 * 'mousefocus' */
6611 need_mouse_correct = save_mouse_correct;
6612 #endif
6613
6614 return retval;
6615 }
6616
6617 /*
6618 * Reload a buffer that is already loaded.
6619 * Used when the file was changed outside of Vim.
6620 * "orig_mode" is buf->b_orig_mode before the need for reloading was detected.
6621 * buf->b_orig_mode may have been reset already.
6622 */
6623 void
6624 buf_reload(buf, orig_mode)
6625 buf_T *buf;
6626 int orig_mode;
6627 {
6628 exarg_T ea;
6629 pos_T old_cursor;
6630 linenr_T old_topline;
6631 int old_ro = buf->b_p_ro;
6632 buf_T *savebuf;
6633 int saved = OK;
6634 aco_save_T aco;
6635
6636 /* set curwin/curbuf for "buf" and save some things */
6637 aucmd_prepbuf(&aco, buf);
6638
6639 /* We only want to read the text from the file, not reset the syntax
6640 * highlighting, clear marks, diff status, etc. Force the fileformat
6641 * and encoding to be the same. */
6642 if (prep_exarg(&ea, buf) == OK)
6643 {
6644 old_cursor = curwin->w_cursor;
6645 old_topline = curwin->w_topline;
6646
6647 /*
6648 * To behave like when a new file is edited (matters for
6649 * BufReadPost autocommands) we first need to delete the current
6650 * buffer contents. But if reading the file fails we should keep
6651 * the old contents. Can't use memory only, the file might be
6652 * too big. Use a hidden buffer to move the buffer contents to.
6653 */
6654 if (bufempty())
6655 savebuf = NULL;
6656 else
6657 {
6658 /* Allocate a buffer without putting it in the buffer list. */
6659 savebuf = buflist_new(NULL, NULL, (linenr_T)1, BLN_DUMMY);
6660 if (savebuf != NULL && buf == curbuf)
6661 {
6662 /* Open the memline. */
6663 curbuf = savebuf;
6664 curwin->w_buffer = savebuf;
6665 saved = ml_open(curbuf);
6666 curbuf = buf;
6667 curwin->w_buffer = buf;
6668 }
6669 if (savebuf == NULL || saved == FAIL || buf != curbuf
6670 || move_lines(buf, savebuf) == FAIL)
6671 {
6672 EMSG2(_("E462: Could not prepare for reloading \"%s\""),
6673 buf->b_fname);
6674 saved = FAIL;
6675 }
6676 }
6677
6678 if (saved == OK)
6679 {
6680 curbuf->b_flags |= BF_CHECK_RO; /* check for RO again */
6681 #ifdef FEAT_AUTOCMD
6682 keep_filetype = TRUE; /* don't detect 'filetype' */
6683 #endif
6684 if (readfile(buf->b_ffname, buf->b_fname, (linenr_T)0,
6685 (linenr_T)0,
6686 (linenr_T)MAXLNUM, &ea, READ_NEW) == FAIL)
6687 {
6688 #if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
6689 if (!aborting())
6690 #endif
6691 EMSG2(_("E321: Could not reload \"%s\""), buf->b_fname);
6692 if (savebuf != NULL && buf_valid(savebuf) && buf == curbuf)
6693 {
6694 /* Put the text back from the save buffer. First
6695 * delete any lines that readfile() added. */
6696 while (!bufempty())
6697 if (ml_delete(buf->b_ml.ml_line_count, FALSE) == FAIL)
6698 break;
6699 (void)move_lines(savebuf, buf);
6700 }
6701 }
6702 else if (buf == curbuf)
6703 {
6704 /* Mark the buffer as unmodified and free undo info. */
6705 unchanged(buf, TRUE);
6706 u_blockfree(buf);
6707 u_clearall(buf);
6708 }
6709 }
6710 vim_free(ea.cmd);
6711
6712 if (savebuf != NULL && buf_valid(savebuf))
6713 wipe_buffer(savebuf, FALSE);
6714
6715 #ifdef FEAT_DIFF
6716 /* Invalidate diff info if necessary. */
6717 diff_invalidate(curbuf);
6718 #endif
6719
6720 /* Restore the topline and cursor position and check it (lines may
6721 * have been removed). */
6722 if (old_topline > curbuf->b_ml.ml_line_count)
6723 curwin->w_topline = curbuf->b_ml.ml_line_count;
6724 else
6725 curwin->w_topline = old_topline;
6726 curwin->w_cursor = old_cursor;
6727 check_cursor();
6728 update_topline();
6729 #ifdef FEAT_AUTOCMD
6730 keep_filetype = FALSE;
6731 #endif
6732 #ifdef FEAT_FOLDING
6733 {
6734 win_T *wp;
6735
6736 /* Update folds unless they are defined manually. */
6737 FOR_ALL_WINDOWS(wp)
6738 if (wp->w_buffer == curwin->w_buffer
6739 && !foldmethodIsManual(wp))
6740 foldUpdateAll(wp);
6741 }
6742 #endif
6743 /* If the mode didn't change and 'readonly' was set, keep the old
6744 * value; the user probably used the ":view" command. But don't
6745 * reset it, might have had a read error. */
6746 if (orig_mode == curbuf->b_orig_mode)
6747 curbuf->b_p_ro |= old_ro;
6748 }
6749
6750 /* restore curwin/curbuf and a few other things */
6751 aucmd_restbuf(&aco);
6752 /* Careful: autocommands may have made "buf" invalid! */
6753 }
6754
6755 /*ARGSUSED*/
6756 void
6757 buf_store_time(buf, st, fname)
6758 buf_T *buf;
6759 struct stat *st;
6760 char_u *fname;
6761 {
6762 buf->b_mtime = (long)st->st_mtime;
6763 buf->b_orig_size = (size_t)st->st_size;
6764 #ifdef HAVE_ST_MODE
6765 buf->b_orig_mode = (int)st->st_mode;
6766 #else
6767 buf->b_orig_mode = mch_getperm(fname);
6768 #endif
6769 }
6770
6771 /*
6772 * Adjust the line with missing eol, used for the next write.
6773 * Used for do_filter(), when the input lines for the filter are deleted.
6774 */
6775 void
6776 write_lnum_adjust(offset)
6777 linenr_T offset;
6778 {
6779 if (write_no_eol_lnum != 0) /* only if there is a missing eol */
6780 write_no_eol_lnum += offset;
6781 }
6782
6783 #if defined(TEMPDIRNAMES) || defined(PROTO)
6784 static long temp_count = 0; /* Temp filename counter. */
6785
6786 /*
6787 * Delete the temp directory and all files it contains.
6788 */
6789 void
6790 vim_deltempdir()
6791 {
6792 char_u **files;
6793 int file_count;
6794 int i;
6795
6796 if (vim_tempdir != NULL)
6797 {
6798 sprintf((char *)NameBuff, "%s*", vim_tempdir);
6799 if (gen_expand_wildcards(1, &NameBuff, &file_count, &files,
6800 EW_DIR|EW_FILE|EW_SILENT) == OK)
6801 {
6802 for (i = 0; i < file_count; ++i)
6803 mch_remove(files[i]);
6804 FreeWild(file_count, files);
6805 }
6806 gettail(NameBuff)[-1] = NUL;
6807 (void)mch_rmdir(NameBuff);
6808
6809 vim_free(vim_tempdir);
6810 vim_tempdir = NULL;
6811 }
6812 }
6813 #endif
6814
6815 /*
6816 * vim_tempname(): Return a unique name that can be used for a temp file.
6817 *
6818 * The temp file is NOT created.
6819 *
6820 * The returned pointer is to allocated memory.
6821 * The returned pointer is NULL if no valid name was found.
6822 */
6823 /*ARGSUSED*/
6824 char_u *
6825 vim_tempname(extra_char)
6826 int extra_char; /* character to use in the name instead of '?' */
6827 {
6828 #ifdef USE_TMPNAM
6829 char_u itmp[L_tmpnam]; /* use tmpnam() */
6830 #else
6831 char_u itmp[TEMPNAMELEN];
6832 #endif
6833
6834 #ifdef TEMPDIRNAMES
6835 static char *(tempdirs[]) = {TEMPDIRNAMES};
6836 int i;
6837 long nr;
6838 long off;
6839 # ifndef EEXIST
6840 struct stat st;
6841 # endif
6842
6843 /*
6844 * This will create a directory for private use by this instance of Vim.
6845 * This is done once, and the same directory is used for all temp files.
6846 * This method avoids security problems because of symlink attacks et al.
6847 * It's also a bit faster, because we only need to check for an existing
6848 * file when creating the directory and not for each temp file.
6849 */
6850 if (vim_tempdir == NULL)
6851 {
6852 /*
6853 * Try the entries in TEMPDIRNAMES to create the temp directory.
6854 */
6855 for (i = 0; i < sizeof(tempdirs) / sizeof(char *); ++i)
6856 {
6857 /* expand $TMP, leave room for "/v1100000/999999999" */
6858 expand_env((char_u *)tempdirs[i], itmp, TEMPNAMELEN - 20);
6859 if (mch_isdir(itmp)) /* directory exists */
6860 {
6861 # ifdef __EMX__
6862 /* If $TMP contains a forward slash (perhaps using bash or
6863 * tcsh), don't add a backslash, use a forward slash!
6864 * Adding 2 backslashes didn't work. */
6865 if (vim_strchr(itmp, '/') != NULL)
6866 STRCAT(itmp, "/");
6867 else
6868 # endif
6869 add_pathsep(itmp);
6870
6871 /* Get an arbitrary number of up to 6 digits. When it's
6872 * unlikely that it already exists it will be faster,
6873 * otherwise it doesn't matter. The use of mkdir() avoids any
6874 * security problems because of the predictable number. */
6875 nr = (mch_get_pid() + (long)time(NULL)) % 1000000L;
6876
6877 /* Try up to 10000 different values until we find a name that
6878 * doesn't exist. */
6879 for (off = 0; off < 10000L; ++off)
6880 {
6881 int r;
6882 #if defined(UNIX) || defined(VMS)
6883 mode_t umask_save;
6884 #endif
6885
6886 sprintf((char *)itmp + STRLEN(itmp), "v%ld", nr + off);
6887 # ifndef EEXIST
6888 /* If mkdir() does not set errno to EEXIST, check for
6889 * existing file here. There is a race condition then,
6890 * although it's fail-safe. */
6891 if (mch_stat((char *)itmp, &st) >= 0)
6892 continue;
6893 # endif
6894 #if defined(UNIX) || defined(VMS)
6895 /* Make sure the umask doesn't remove the executable bit.
6896 * "repl" has been reported to use "177". */
6897 umask_save = umask(077);
6898 #endif
6899 r = vim_mkdir(itmp, 0700);
6900 #if defined(UNIX) || defined(VMS)
6901 (void)umask(umask_save);
6902 #endif
6903 if (r == 0)
6904 {
6905 char_u *buf;
6906
6907 /* Directory was created, use this name.
6908 * Expand to full path; When using the current
6909 * directory a ":cd" would confuse us. */
6910 buf = alloc((unsigned)MAXPATHL + 1);
6911 if (buf != NULL)
6912 {
6913 if (vim_FullName(itmp, buf, MAXPATHL, FALSE)
6914 == FAIL)
6915 STRCPY(buf, itmp);
6916 # ifdef __EMX__
6917 if (vim_strchr(buf, '/') != NULL)
6918 STRCAT(buf, "/");
6919 else
6920 # endif
6921 add_pathsep(buf);
6922 vim_tempdir = vim_strsave(buf);
6923 vim_free(buf);
6924 }
6925 break;
6926 }
6927 # ifdef EEXIST
6928 /* If the mkdir() didn't fail because the file/dir exists,
6929 * we probably can't create any dir here, try another
6930 * place. */
6931 if (errno != EEXIST)
6932 # endif
6933 break;
6934 }
6935 if (vim_tempdir != NULL)
6936 break;
6937 }
6938 }
6939 }
6940
6941 if (vim_tempdir != NULL)
6942 {
6943 /* There is no need to check if the file exists, because we own the
6944 * directory and nobody else creates a file in it. */
6945 sprintf((char *)itmp, "%s%ld", vim_tempdir, temp_count++);
6946 return vim_strsave(itmp);
6947 }
6948
6949 return NULL;
6950
6951 #else /* TEMPDIRNAMES */
6952
6953 # ifdef WIN3264
6954 char szTempFile[_MAX_PATH + 1];
6955 char buf4[4];
6956 char_u *retval;
6957 char_u *p;
6958
6959 STRCPY(itmp, "");
6960 if (GetTempPath(_MAX_PATH, szTempFile) == 0)
6961 szTempFile[0] = NUL; /* GetTempPath() failed, use current dir */
6962 strcpy(buf4, "VIM");
6963 buf4[2] = extra_char; /* make it "VIa", "VIb", etc. */
6964 if (GetTempFileName(szTempFile, buf4, 0, itmp) == 0)
6965 return NULL;
6966 /* GetTempFileName() will create the file, we don't want that */
6967 (void)DeleteFile(itmp);
6968
6969 /* Backslashes in a temp file name cause problems when filtering with
6970 * "sh". NOTE: This also checks 'shellcmdflag' to help those people who
6971 * didn't set 'shellslash'. */
6972 retval = vim_strsave(itmp);
6973 if (*p_shcf == '-' || p_ssl)
6974 for (p = retval; *p; ++p)
6975 if (*p == '\\')
6976 *p = '/';
6977 return retval;
6978
6979 # else /* WIN3264 */
6980
6981 # ifdef USE_TMPNAM
6982 /* tmpnam() will make its own name */
6983 if (*tmpnam((char *)itmp) == NUL)
6984 return NULL;
6985 # else
6986 char_u *p;
6987
6988 # ifdef VMS_TEMPNAM
6989 /* mktemp() is not working on VMS. It seems to be
6990 * a do-nothing function. Therefore we use tempnam().
6991 */
6992 sprintf((char *)itmp, "VIM%c", extra_char);
6993 p = (char_u *)tempnam("tmp:", (char *)itmp);
6994 if (p != NULL)
6995 {
6996 /* VMS will use '.LOG' if we don't explicitly specify an extension,
6997 * and VIM will then be unable to find the file later */
6998 STRCPY(itmp, p);
6999 STRCAT(itmp, ".txt");
7000 free(p);
7001 }
7002 else
7003 return NULL;
7004 # else
7005 STRCPY(itmp, TEMPNAME);
7006 if ((p = vim_strchr(itmp, '?')) != NULL)
7007 *p = extra_char;
7008 if (mktemp((char *)itmp) == NULL)
7009 return NULL;
7010 # endif
7011 # endif
7012
7013 return vim_strsave(itmp);
7014 # endif /* WIN3264 */
7015 #endif /* TEMPDIRNAMES */
7016 }
7017
7018 #if defined(BACKSLASH_IN_FILENAME) || defined(PROTO)
7019 /*
7020 * Convert all backslashes in fname to forward slashes in-place.
7021 */
7022 void
7023 forward_slash(fname)
7024 char_u *fname;
7025 {
7026 char_u *p;
7027
7028 for (p = fname; *p != NUL; ++p)
7029 # ifdef FEAT_MBYTE
7030 /* The Big5 encoding can have '\' in the trail byte. */
7031 if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
7032 ++p;
7033 else
7034 # endif
7035 if (*p == '\\')
7036 *p = '/';
7037 }
7038 #endif
7039
7040
7041 /*
7042 * Code for automatic commands.
7043 *
7044 * Only included when "FEAT_AUTOCMD" has been defined.
7045 */
7046
7047 #if defined(FEAT_AUTOCMD) || defined(PROTO)
7048
7049 /*
7050 * The autocommands are stored in a list for each event.
7051 * Autocommands for the same pattern, that are consecutive, are joined
7052 * together, to avoid having to match the pattern too often.
7053 * The result is an array of Autopat lists, which point to AutoCmd lists:
7054 *
7055 * first_autopat[0] --> Autopat.next --> Autopat.next --> NULL
7056 * Autopat.cmds Autopat.cmds
7057 * | |
7058 * V V
7059 * AutoCmd.next AutoCmd.next
7060 * | |
7061 * V V
7062 * AutoCmd.next NULL
7063 * |
7064 * V
7065 * NULL
7066 *
7067 * first_autopat[1] --> Autopat.next --> NULL
7068 * Autopat.cmds
7069 * |
7070 * V
7071 * AutoCmd.next
7072 * |
7073 * V
7074 * NULL
7075 * etc.
7076 *
7077 * The order of AutoCmds is important, this is the order in which they were
7078 * defined and will have to be executed.
7079 */
7080 typedef struct AutoCmd
7081 {
7082 char_u *cmd; /* The command to be executed (NULL
7083 when command has been removed) */
7084 char nested; /* If autocommands nest here */
7085 char last; /* last command in list */
7086 #ifdef FEAT_EVAL
7087 scid_T scriptID; /* script ID where defined */
7088 #endif
7089 struct AutoCmd *next; /* Next AutoCmd in list */
7090 } AutoCmd;
7091
7092 typedef struct AutoPat
7093 {
7094 int group; /* group ID */
7095 char_u *pat; /* pattern as typed (NULL when pattern
7096 has been removed) */
7097 int patlen; /* strlen() of pat */
7098 regprog_T *reg_prog; /* compiled regprog for pattern */
7099 char allow_dirs; /* Pattern may match whole path */
7100 char last; /* last pattern for apply_autocmds() */
7101 AutoCmd *cmds; /* list of commands to do */
7102 struct AutoPat *next; /* next AutoPat in AutoPat list */
7103 int buflocal_nr; /* !=0 for buffer-local AutoPat */
7104 } AutoPat;
7105
7106 static struct event_name
7107 {
7108 char *name; /* event name */
7109 event_T event; /* event number */
7110 } event_names[] =
7111 {
7112 {"BufAdd", EVENT_BUFADD},
7113 {"BufCreate", EVENT_BUFADD},
7114 {"BufDelete", EVENT_BUFDELETE},
7115 {"BufEnter", EVENT_BUFENTER},
7116 {"BufFilePost", EVENT_BUFFILEPOST},
7117 {"BufFilePre", EVENT_BUFFILEPRE},
7118 {"BufHidden", EVENT_BUFHIDDEN},
7119 {"BufLeave", EVENT_BUFLEAVE},
7120 {"BufNew", EVENT_BUFNEW},
7121 {"BufNewFile", EVENT_BUFNEWFILE},
7122 {"BufRead", EVENT_BUFREADPOST},
7123 {"BufReadCmd", EVENT_BUFREADCMD},
7124 {"BufReadPost", EVENT_BUFREADPOST},
7125 {"BufReadPre", EVENT_BUFREADPRE},
7126 {"BufUnload", EVENT_BUFUNLOAD},
7127 {"BufWinEnter", EVENT_BUFWINENTER},
7128 {"BufWinLeave", EVENT_BUFWINLEAVE},
7129 {"BufWipeout", EVENT_BUFWIPEOUT},
7130 {"BufWrite", EVENT_BUFWRITEPRE},
7131 {"BufWritePost", EVENT_BUFWRITEPOST},
7132 {"BufWritePre", EVENT_BUFWRITEPRE},
7133 {"BufWriteCmd", EVENT_BUFWRITECMD},
7134 {"CmdwinEnter", EVENT_CMDWINENTER},
7135 {"CmdwinLeave", EVENT_CMDWINLEAVE},
7136 {"ColorScheme", EVENT_COLORSCHEME},
7137 {"CursorHold", EVENT_CURSORHOLD},
7138 {"CursorHoldI", EVENT_CURSORHOLDI},
7139 {"CursorMoved", EVENT_CURSORMOVED},
7140 {"CursorMovedI", EVENT_CURSORMOVEDI},
7141 {"EncodingChanged", EVENT_ENCODINGCHANGED},
7142 {"FileEncoding", EVENT_ENCODINGCHANGED},
7143 {"FileAppendPost", EVENT_FILEAPPENDPOST},
7144 {"FileAppendPre", EVENT_FILEAPPENDPRE},
7145 {"FileAppendCmd", EVENT_FILEAPPENDCMD},
7146 {"FileChangedShell",EVENT_FILECHANGEDSHELL},
7147 {"FileChangedShellPost",EVENT_FILECHANGEDSHELLPOST},
7148 {"FileChangedRO", EVENT_FILECHANGEDRO},
7149 {"FileReadPost", EVENT_FILEREADPOST},
7150 {"FileReadPre", EVENT_FILEREADPRE},
7151 {"FileReadCmd", EVENT_FILEREADCMD},
7152 {"FileType", EVENT_FILETYPE},
7153 {"FileWritePost", EVENT_FILEWRITEPOST},
7154 {"FileWritePre", EVENT_FILEWRITEPRE},
7155 {"FileWriteCmd", EVENT_FILEWRITECMD},
7156 {"FilterReadPost", EVENT_FILTERREADPOST},
7157 {"FilterReadPre", EVENT_FILTERREADPRE},
7158 {"FilterWritePost", EVENT_FILTERWRITEPOST},
7159 {"FilterWritePre", EVENT_FILTERWRITEPRE},
7160 {"FocusGained", EVENT_FOCUSGAINED},
7161 {"FocusLost", EVENT_FOCUSLOST},
7162 {"FuncUndefined", EVENT_FUNCUNDEFINED},
7163 {"GUIEnter", EVENT_GUIENTER},
7164 {"GUIFailed", EVENT_GUIFAILED},
7165 {"InsertChange", EVENT_INSERTCHANGE},
7166 {"InsertEnter", EVENT_INSERTENTER},
7167 {"InsertLeave", EVENT_INSERTLEAVE},
7168 {"MenuPopup", EVENT_MENUPOPUP},
7169 {"QuickFixCmdPost", EVENT_QUICKFIXCMDPOST},
7170 {"QuickFixCmdPre", EVENT_QUICKFIXCMDPRE},
7171 {"RemoteReply", EVENT_REMOTEREPLY},
7172 {"SessionLoadPost", EVENT_SESSIONLOADPOST},
7173 {"ShellCmdPost", EVENT_SHELLCMDPOST},
7174 {"ShellFilterPost", EVENT_SHELLFILTERPOST},
7175 {"SourcePre", EVENT_SOURCEPRE},
7176 {"SourceCmd", EVENT_SOURCECMD},
7177 {"SpellFileMissing",EVENT_SPELLFILEMISSING},
7178 {"StdinReadPost", EVENT_STDINREADPOST},
7179 {"StdinReadPre", EVENT_STDINREADPRE},
7180 {"SwapExists", EVENT_SWAPEXISTS},
7181 {"Syntax", EVENT_SYNTAX},
7182 {"TabEnter", EVENT_TABENTER},
7183 {"TabLeave", EVENT_TABLEAVE},
7184 {"TermChanged", EVENT_TERMCHANGED},
7185 {"TermResponse", EVENT_TERMRESPONSE},
7186 {"User", EVENT_USER},
7187 {"VimEnter", EVENT_VIMENTER},
7188 {"VimLeave", EVENT_VIMLEAVE},
7189 {"VimLeavePre", EVENT_VIMLEAVEPRE},
7190 {"WinEnter", EVENT_WINENTER},
7191 {"WinLeave", EVENT_WINLEAVE},
7192 {"VimResized", EVENT_VIMRESIZED},
7193 {NULL, (event_T)0}
7194 };
7195
7196 static AutoPat *first_autopat[NUM_EVENTS] =
7197 {
7198 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7199 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7200 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7201 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7202 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7203 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
7204 };
7205
7206 /*
7207 * struct used to keep status while executing autocommands for an event.
7208 */
7209 typedef struct AutoPatCmd
7210 {
7211 AutoPat *curpat; /* next AutoPat to examine */
7212 AutoCmd *nextcmd; /* next AutoCmd to execute */
7213 int group; /* group being used */
7214 char_u *fname; /* fname to match with */
7215 char_u *sfname; /* sfname to match with */
7216 char_u *tail; /* tail of fname */
7217 event_T event; /* current event */
7218 int arg_bufnr; /* initially equal to <abuf>, set to zero when
7219 buf is deleted */
7220 struct AutoPatCmd *next; /* chain of active apc-s for auto-invalidation*/
7221 } AutoPatCmd;
7222
7223 static AutoPatCmd *active_apc_list = NULL; /* stack of active autocommands */
7224
7225 /*
7226 * augroups stores a list of autocmd group names.
7227 */
7228 static garray_T augroups = {0, 0, sizeof(char_u *), 10, NULL};
7229 #define AUGROUP_NAME(i) (((char_u **)augroups.ga_data)[i])
7230
7231 /*
7232 * The ID of the current group. Group 0 is the default one.
7233 */
7234 static int current_augroup = AUGROUP_DEFAULT;
7235
7236 static int au_need_clean = FALSE; /* need to delete marked patterns */
7237
7238 static void show_autocmd __ARGS((AutoPat *ap, event_T event));
7239 static void au_remove_pat __ARGS((AutoPat *ap));
7240 static void au_remove_cmds __ARGS((AutoPat *ap));
7241 static void au_cleanup __ARGS((void));
7242 static int au_new_group __ARGS((char_u *name));
7243 static void au_del_group __ARGS((char_u *name));
7244 static event_T event_name2nr __ARGS((char_u *start, char_u **end));
7245 static char_u *event_nr2name __ARGS((event_T event));
7246 static char_u *find_end_event __ARGS((char_u *arg, int have_group));
7247 static int event_ignored __ARGS((event_T event));
7248 static int au_get_grouparg __ARGS((char_u **argp));
7249 static int do_autocmd_event __ARGS((event_T event, char_u *pat, int nested, char_u *cmd, int forceit, int group));
7250 static char_u *getnextac __ARGS((int c, void *cookie, int indent));
7251 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));
7252 static void auto_next_pat __ARGS((AutoPatCmd *apc, int stop_at_last));
7253
7254
7255 static event_T last_event;
7256 static int last_group;
7257 static int autocmd_blocked = 0; /* block all autocmds */
7258
7259 /*
7260 * Show the autocommands for one AutoPat.
7261 */
7262 static void
7263 show_autocmd(ap, event)
7264 AutoPat *ap;
7265 event_T event;
7266 {
7267 AutoCmd *ac;
7268
7269 /* Check for "got_int" (here and at various places below), which is set
7270 * when "q" has been hit for the "--more--" prompt */
7271 if (got_int)
7272 return;
7273 if (ap->pat == NULL) /* pattern has been removed */
7274 return;
7275
7276 msg_putchar('\n');
7277 if (got_int)
7278 return;
7279 if (event != last_event || ap->group != last_group)
7280 {
7281 if (ap->group != AUGROUP_DEFAULT)
7282 {
7283 if (AUGROUP_NAME(ap->group) == NULL)
7284 msg_puts_attr((char_u *)_("--Deleted--"), hl_attr(HLF_E));
7285 else
7286 msg_puts_attr(AUGROUP_NAME(ap->group), hl_attr(HLF_T));
7287 msg_puts((char_u *)" ");
7288 }
7289 msg_puts_attr(event_nr2name(event), hl_attr(HLF_T));
7290 last_event = event;
7291 last_group = ap->group;
7292 msg_putchar('\n');
7293 if (got_int)
7294 return;
7295 }
7296 msg_col = 4;
7297 msg_outtrans(ap->pat);
7298
7299 for (ac = ap->cmds; ac != NULL; ac = ac->next)
7300 {
7301 if (ac->cmd != NULL) /* skip removed commands */
7302 {
7303 if (msg_col >= 14)
7304 msg_putchar('\n');
7305 msg_col = 14;
7306 if (got_int)
7307 return;
7308 msg_outtrans(ac->cmd);
7309 #ifdef FEAT_EVAL
7310 if (p_verbose > 0)
7311 last_set_msg(ac->scriptID);
7312 #endif
7313 if (got_int)
7314 return;
7315 if (ac->next != NULL)
7316 {
7317 msg_putchar('\n');
7318 if (got_int)
7319 return;
7320 }
7321 }
7322 }
7323 }
7324
7325 /*
7326 * Mark an autocommand pattern for deletion.
7327 */
7328 static void
7329 au_remove_pat(ap)
7330 AutoPat *ap;
7331 {
7332 vim_free(ap->pat);
7333 ap->pat = NULL;
7334 ap->buflocal_nr = -1;
7335 au_need_clean = TRUE;
7336 }
7337
7338 /*
7339 * Mark all commands for a pattern for deletion.
7340 */
7341 static void
7342 au_remove_cmds(ap)
7343 AutoPat *ap;
7344 {
7345 AutoCmd *ac;
7346
7347 for (ac = ap->cmds; ac != NULL; ac = ac->next)
7348 {
7349 vim_free(ac->cmd);
7350 ac->cmd = NULL;
7351 }
7352 au_need_clean = TRUE;
7353 }
7354
7355 /*
7356 * Cleanup autocommands and patterns that have been deleted.
7357 * This is only done when not executing autocommands.
7358 */
7359 static void
7360 au_cleanup()
7361 {
7362 AutoPat *ap, **prev_ap;
7363 AutoCmd *ac, **prev_ac;
7364 event_T event;
7365
7366 if (autocmd_busy || !au_need_clean)
7367 return;
7368
7369 /* loop over all events */
7370 for (event = (event_T)0; (int)event < (int)NUM_EVENTS;
7371 event = (event_T)((int)event + 1))
7372 {
7373 /* loop over all autocommand patterns */
7374 prev_ap = &(first_autopat[(int)event]);
7375 for (ap = *prev_ap; ap != NULL; ap = *prev_ap)
7376 {
7377 /* loop over all commands for this pattern */
7378 prev_ac = &(ap->cmds);
7379 for (ac = *prev_ac; ac != NULL; ac = *prev_ac)
7380 {
7381 /* remove the command if the pattern is to be deleted or when
7382 * the command has been marked for deletion */
7383 if (ap->pat == NULL || ac->cmd == NULL)
7384 {
7385 *prev_ac = ac->next;
7386 vim_free(ac->cmd);
7387 vim_free(ac);
7388 }
7389 else
7390 prev_ac = &(ac->next);
7391 }
7392
7393 /* remove the pattern if it has been marked for deletion */
7394 if (ap->pat == NULL)
7395 {
7396 *prev_ap = ap->next;
7397 vim_free(ap->reg_prog);
7398 vim_free(ap);
7399 }
7400 else
7401 prev_ap = &(ap->next);
7402 }
7403 }
7404
7405 au_need_clean = FALSE;
7406 }
7407
7408 /*
7409 * Called when buffer is freed, to remove/invalidate related buffer-local
7410 * autocmds.
7411 */
7412 void
7413 aubuflocal_remove(buf)
7414 buf_T *buf;
7415 {
7416 AutoPat *ap;
7417 event_T event;
7418 AutoPatCmd *apc;
7419
7420 /* invalidate currently executing autocommands */
7421 for (apc = active_apc_list; apc; apc = apc->next)
7422 if (buf->b_fnum == apc->arg_bufnr)
7423 apc->arg_bufnr = 0;
7424
7425 /* invalidate buflocals looping through events */
7426 for (event = (event_T)0; (int)event < (int)NUM_EVENTS;
7427 event = (event_T)((int)event + 1))
7428 /* loop over all autocommand patterns */
7429 for (ap = first_autopat[(int)event]; ap != NULL; ap = ap->next)
7430 if (ap->buflocal_nr == buf->b_fnum)
7431 {
7432 au_remove_pat(ap);
7433 if (p_verbose >= 6)
7434 {
7435 verbose_enter();
7436 smsg((char_u *)
7437 _("auto-removing autocommand: %s <buffer=%d>"),
7438 event_nr2name(event), buf->b_fnum);
7439 verbose_leave();
7440 }
7441 }
7442 au_cleanup();
7443 }
7444
7445 /*
7446 * Add an autocmd group name.
7447 * Return it's ID. Returns AUGROUP_ERROR (< 0) for error.
7448 */
7449 static int
7450 au_new_group(name)
7451 char_u *name;
7452 {
7453 int i;
7454
7455 i = au_find_group(name);
7456 if (i == AUGROUP_ERROR) /* the group doesn't exist yet, add it */
7457 {
7458 /* First try using a free entry. */
7459 for (i = 0; i < augroups.ga_len; ++i)
7460 if (AUGROUP_NAME(i) == NULL)
7461 break;
7462 if (i == augroups.ga_len && ga_grow(&augroups, 1) == FAIL)
7463 return AUGROUP_ERROR;
7464
7465 AUGROUP_NAME(i) = vim_strsave(name);
7466 if (AUGROUP_NAME(i) == NULL)
7467 return AUGROUP_ERROR;
7468 if (i == augroups.ga_len)
7469 ++augroups.ga_len;
7470 }
7471
7472 return i;
7473 }
7474
7475 static void
7476 au_del_group(name)
7477 char_u *name;
7478 {
7479 int i;
7480
7481 i = au_find_group(name);
7482 if (i == AUGROUP_ERROR) /* the group doesn't exist */
7483 EMSG2(_("E367: No such group: \"%s\""), name);
7484 else
7485 {
7486 vim_free(AUGROUP_NAME(i));
7487 AUGROUP_NAME(i) = NULL;
7488 }
7489 }
7490
7491 /*
7492 * Find the ID of an autocmd group name.
7493 * Return it's ID. Returns AUGROUP_ERROR (< 0) for error.
7494 */
7495 static int
7496 au_find_group(name)
7497 char_u *name;
7498 {
7499 int i;
7500
7501 for (i = 0; i < augroups.ga_len; ++i)
7502 if (AUGROUP_NAME(i) != NULL && STRCMP(AUGROUP_NAME(i), name) == 0)
7503 return i;
7504 return AUGROUP_ERROR;
7505 }
7506
7507 /*
7508 * Return TRUE if augroup "name" exists.
7509 */
7510 int
7511 au_has_group(name)
7512 char_u *name;
7513 {
7514 return au_find_group(name) != AUGROUP_ERROR;
7515 }
7516
7517 /*
7518 * ":augroup {name}".
7519 */
7520 void
7521 do_augroup(arg, del_group)
7522 char_u *arg;
7523 int del_group;
7524 {
7525 int i;
7526
7527 if (del_group)
7528 {
7529 if (*arg == NUL)
7530 EMSG(_(e_argreq));
7531 else
7532 au_del_group(arg);
7533 }
7534 else if (STRICMP(arg, "end") == 0) /* ":aug end": back to group 0 */
7535 current_augroup = AUGROUP_DEFAULT;
7536 else if (*arg) /* ":aug xxx": switch to group xxx */
7537 {
7538 i = au_new_group(arg);
7539 if (i != AUGROUP_ERROR)
7540 current_augroup = i;
7541 }
7542 else /* ":aug": list the group names */
7543 {
7544 msg_start();
7545 for (i = 0; i < augroups.ga_len; ++i)
7546 {
7547 if (AUGROUP_NAME(i) != NULL)
7548 {
7549 msg_puts(AUGROUP_NAME(i));
7550 msg_puts((char_u *)" ");
7551 }
7552 }
7553 msg_clr_eos();
7554 msg_end();
7555 }
7556 }
7557
7558 #if defined(EXITFREE) || defined(PROTO)
7559 void
7560 free_all_autocmds()
7561 {
7562 for (current_augroup = -1; current_augroup < augroups.ga_len;
7563 ++current_augroup)
7564 do_autocmd((char_u *)"", TRUE);
7565 ga_clear_strings(&augroups);
7566 }
7567 #endif
7568
7569 /*
7570 * Return the event number for event name "start".
7571 * Return NUM_EVENTS if the event name was not found.
7572 * Return a pointer to the next event name in "end".
7573 */
7574 static event_T
7575 event_name2nr(start, end)
7576 char_u *start;
7577 char_u **end;
7578 {
7579 char_u *p;
7580 int i;
7581 int len;
7582
7583 /* the event name ends with end of line, a blank or a comma */
7584 for (p = start; *p && !vim_iswhite(*p) && *p != ','; ++p)
7585 ;
7586 for (i = 0; event_names[i].name != NULL; ++i)
7587 {
7588 len = (int)STRLEN(event_names[i].name);
7589 if (len == p - start && STRNICMP(event_names[i].name, start, len) == 0)
7590 break;
7591 }
7592 if (*p == ',')
7593 ++p;
7594 *end = p;
7595 if (event_names[i].name == NULL)
7596 return NUM_EVENTS;
7597 return event_names[i].event;
7598 }
7599
7600 /*
7601 * Return the name for event "event".
7602 */
7603 static char_u *
7604 event_nr2name(event)
7605 event_T event;
7606 {
7607 int i;
7608
7609 for (i = 0; event_names[i].name != NULL; ++i)
7610 if (event_names[i].event == event)
7611 return (char_u *)event_names[i].name;
7612 return (char_u *)"Unknown";
7613 }
7614
7615 /*
7616 * Scan over the events. "*" stands for all events.
7617 */
7618 static char_u *
7619 find_end_event(arg, have_group)
7620 char_u *arg;
7621 int have_group; /* TRUE when group name was found */
7622 {
7623 char_u *pat;
7624 char_u *p;
7625
7626 if (*arg == '*')
7627 {
7628 if (arg[1] && !vim_iswhite(arg[1]))
7629 {
7630 EMSG2(_("E215: Illegal character after *: %s"), arg);
7631 return NULL;
7632 }
7633 pat = arg + 1;
7634 }
7635 else
7636 {
7637 for (pat = arg; *pat && !vim_iswhite(*pat); pat = p)
7638 {
7639 if ((int)event_name2nr(pat, &p) >= (int)NUM_EVENTS)
7640 {
7641 if (have_group)
7642 EMSG2(_("E216: No such event: %s"), pat);
7643 else
7644 EMSG2(_("E216: No such group or event: %s"), pat);
7645 return NULL;
7646 }
7647 }
7648 }
7649 return pat;
7650 }
7651
7652 /*
7653 * Return TRUE if "event" is included in 'eventignore'.
7654 */
7655 static int
7656 event_ignored(event)
7657 event_T event;
7658 {
7659 char_u *p = p_ei;
7660
7661 while (*p != NUL)
7662 {
7663 if (STRNICMP(p, "all", 3) == 0 && (p[3] == NUL || p[3] == ','))
7664 return TRUE;
7665 if (event_name2nr(p, &p) == event)
7666 return TRUE;
7667 }
7668
7669 return FALSE;
7670 }
7671
7672 /*
7673 * Return OK when the contents of p_ei is valid, FAIL otherwise.
7674 */
7675 int
7676 check_ei()
7677 {
7678 char_u *p = p_ei;
7679
7680 while (*p)
7681 {
7682 if (STRNICMP(p, "all", 3) == 0 && (p[3] == NUL || p[3] == ','))
7683 {
7684 p += 3;
7685 if (*p == ',')
7686 ++p;
7687 }
7688 else if (event_name2nr(p, &p) == NUM_EVENTS)
7689 return FAIL;
7690 }
7691
7692 return OK;
7693 }
7694
7695 # if defined(FEAT_SYN_HL) || defined(PROTO)
7696
7697 /*
7698 * Add "what" to 'eventignore' to skip loading syntax highlighting for every
7699 * buffer loaded into the window. "what" must start with a comma.
7700 * Returns the old value of 'eventignore' in allocated memory.
7701 */
7702 char_u *
7703 au_event_disable(what)
7704 char *what;
7705 {
7706 char_u *new_ei;
7707 char_u *save_ei;
7708
7709 save_ei = vim_strsave(p_ei);
7710 if (save_ei != NULL)
7711 {
7712 new_ei = vim_strnsave(p_ei, (int)(STRLEN(p_ei) + STRLEN(what)));
7713 if (new_ei != NULL)
7714 {
7715 STRCAT(new_ei, what);
7716 set_string_option_direct((char_u *)"ei", -1, new_ei,
7717 OPT_FREE, SID_NONE);
7718 vim_free(new_ei);
7719 }
7720 }
7721 return save_ei;
7722 }
7723
7724 void
7725 au_event_restore(old_ei)
7726 char_u *old_ei;
7727 {
7728 if (old_ei != NULL)
7729 {
7730 set_string_option_direct((char_u *)"ei", -1, old_ei,
7731 OPT_FREE, SID_NONE);
7732 vim_free(old_ei);
7733 }
7734 }
7735 # endif /* FEAT_SYN_HL */
7736
7737 /*
7738 * do_autocmd() -- implements the :autocmd command. Can be used in the
7739 * following ways:
7740 *
7741 * :autocmd <event> <pat> <cmd> Add <cmd> to the list of commands that
7742 * will be automatically executed for <event>
7743 * when editing a file matching <pat>, in
7744 * the current group.
7745 * :autocmd <event> <pat> Show the auto-commands associated with
7746 * <event> and <pat>.
7747 * :autocmd <event> Show the auto-commands associated with
7748 * <event>.
7749 * :autocmd Show all auto-commands.
7750 * :autocmd! <event> <pat> <cmd> Remove all auto-commands associated with
7751 * <event> and <pat>, and add the command
7752 * <cmd>, for the current group.
7753 * :autocmd! <event> <pat> Remove all auto-commands associated with
7754 * <event> and <pat> for the current group.
7755 * :autocmd! <event> Remove all auto-commands associated with
7756 * <event> for the current group.
7757 * :autocmd! Remove ALL auto-commands for the current
7758 * group.
7759 *
7760 * Multiple events and patterns may be given separated by commas. Here are
7761 * some examples:
7762 * :autocmd bufread,bufenter *.c,*.h set tw=0 smartindent noic
7763 * :autocmd bufleave * set tw=79 nosmartindent ic infercase
7764 *
7765 * :autocmd * *.c show all autocommands for *.c files.
7766 *
7767 * Mostly a {group} argument can optionally appear before <event>.
7768 */
7769 void
7770 do_autocmd(arg, forceit)
7771 char_u *arg;
7772 int forceit;
7773 {
7774 char_u *pat;
7775 char_u *envpat = NULL;
7776 char_u *cmd;
7777 event_T event;
7778 int need_free = FALSE;
7779 int nested = FALSE;
7780 int group;
7781
7782 /*
7783 * Check for a legal group name. If not, use AUGROUP_ALL.
7784 */
7785 group = au_get_grouparg(&arg);
7786 if (arg == NULL) /* out of memory */
7787 return;
7788
7789 /*
7790 * Scan over the events.
7791 * If we find an illegal name, return here, don't do anything.
7792 */
7793 pat = find_end_event(arg, group != AUGROUP_ALL);
7794 if (pat == NULL)
7795 return;
7796
7797 /*
7798 * Scan over the pattern. Put a NUL at the end.
7799 */
7800 pat = skipwhite(pat);
7801 cmd = pat;
7802 while (*cmd && (!vim_iswhite(*cmd) || cmd[-1] == '\\'))
7803 cmd++;
7804 if (*cmd)
7805 *cmd++ = NUL;
7806
7807 /* Expand environment variables in the pattern. Set 'shellslash', we want
7808 * forward slashes here. */
7809 if (vim_strchr(pat, '$') != NULL || vim_strchr(pat, '~') != NULL)
7810 {
7811 #ifdef BACKSLASH_IN_FILENAME
7812 int p_ssl_save = p_ssl;
7813
7814 p_ssl = TRUE;
7815 #endif
7816 envpat = expand_env_save(pat);
7817 #ifdef BACKSLASH_IN_FILENAME
7818 p_ssl = p_ssl_save;
7819 #endif
7820 if (envpat != NULL)
7821 pat = envpat;
7822 }
7823
7824 /*
7825 * Check for "nested" flag.
7826 */
7827 cmd = skipwhite(cmd);
7828 if (*cmd != NUL && STRNCMP(cmd, "nested", 6) == 0 && vim_iswhite(cmd[6]))
7829 {
7830 nested = TRUE;
7831 cmd = skipwhite(cmd + 6);
7832 }
7833
7834 /*
7835 * Find the start of the commands.
7836 * Expand <sfile> in it.
7837 */
7838 if (*cmd != NUL)
7839 {
7840 cmd = expand_sfile(cmd);
7841 if (cmd == NULL) /* some error */
7842 return;
7843 need_free = TRUE;
7844 }
7845
7846 /*
7847 * Print header when showing autocommands.
7848 */
7849 if (!forceit && *cmd == NUL)
7850 {
7851 /* Highlight title */
7852 MSG_PUTS_TITLE(_("\n--- Auto-Commands ---"));
7853 }
7854
7855 /*
7856 * Loop over the events.
7857 */
7858 last_event = (event_T)-1; /* for listing the event name */
7859 last_group = AUGROUP_ERROR; /* for listing the group name */
7860 if (*arg == '*' || *arg == NUL)
7861 {
7862 for (event = (event_T)0; (int)event < (int)NUM_EVENTS;
7863 event = (event_T)((int)event + 1))
7864 if (do_autocmd_event(event, pat,
7865 nested, cmd, forceit, group) == FAIL)
7866 break;
7867 }
7868 else
7869 {
7870 while (*arg && !vim_iswhite(*arg))
7871 if (do_autocmd_event(event_name2nr(arg, &arg), pat,
7872 nested, cmd, forceit, group) == FAIL)
7873 break;
7874 }
7875
7876 if (need_free)
7877 vim_free(cmd);
7878 vim_free(envpat);
7879 }
7880
7881 /*
7882 * Find the group ID in a ":autocmd" or ":doautocmd" argument.
7883 * The "argp" argument is advanced to the following argument.
7884 *
7885 * Returns the group ID, AUGROUP_ERROR for error (out of memory).
7886 */
7887 static int
7888 au_get_grouparg(argp)
7889 char_u **argp;
7890 {
7891 char_u *group_name;
7892 char_u *p;
7893 char_u *arg = *argp;
7894 int group = AUGROUP_ALL;
7895
7896 p = skiptowhite(arg);
7897 if (p > arg)
7898 {
7899 group_name = vim_strnsave(arg, (int)(p - arg));
7900 if (group_name == NULL) /* out of memory */
7901 return AUGROUP_ERROR;
7902 group = au_find_group(group_name);
7903 if (group == AUGROUP_ERROR)
7904 group = AUGROUP_ALL; /* no match, use all groups */
7905 else
7906 *argp = skipwhite(p); /* match, skip over group name */
7907 vim_free(group_name);
7908 }
7909 return group;
7910 }
7911
7912 /*
7913 * do_autocmd() for one event.
7914 * If *pat == NUL do for all patterns.
7915 * If *cmd == NUL show entries.
7916 * If forceit == TRUE delete entries.
7917 * If group is not AUGROUP_ALL, only use this group.
7918 */
7919 static int
7920 do_autocmd_event(event, pat, nested, cmd, forceit, group)
7921 event_T event;
7922 char_u *pat;
7923 int nested;
7924 char_u *cmd;
7925 int forceit;
7926 int group;
7927 {
7928 AutoPat *ap;
7929 AutoPat **prev_ap;
7930 AutoCmd *ac;
7931 AutoCmd **prev_ac;
7932 int brace_level;
7933 char_u *endpat;
7934 int findgroup;
7935 int allgroups;
7936 int patlen;
7937 int is_buflocal;
7938 int buflocal_nr;
7939 char_u buflocal_pat[25]; /* for "<buffer=X>" */
7940
7941 if (group == AUGROUP_ALL)
7942 findgroup = current_augroup;
7943 else
7944 findgroup = group;
7945 allgroups = (group == AUGROUP_ALL && !forceit && *cmd == NUL);
7946
7947 /*
7948 * Show or delete all patterns for an event.
7949 */
7950 if (*pat == NUL)
7951 {
7952 for (ap = first_autopat[(int)event]; ap != NULL; ap = ap->next)
7953 {
7954 if (forceit) /* delete the AutoPat, if it's in the current group */
7955 {
7956 if (ap->group == findgroup)
7957 au_remove_pat(ap);
7958 }
7959 else if (group == AUGROUP_ALL || ap->group == group)
7960 show_autocmd(ap, event);
7961 }
7962 }
7963
7964 /*
7965 * Loop through all the specified patterns.
7966 */
7967 for ( ; *pat; pat = (*endpat == ',' ? endpat + 1 : endpat))
7968 {
7969 /*
7970 * Find end of the pattern.
7971 * Watch out for a comma in braces, like "*.\{obj,o\}".
7972 */
7973 brace_level = 0;
7974 for (endpat = pat; *endpat && (*endpat != ',' || brace_level
7975 || endpat[-1] == '\\'); ++endpat)
7976 {
7977 if (*endpat == '{')
7978 brace_level++;
7979 else if (*endpat == '}')
7980 brace_level--;
7981 }
7982 if (pat == endpat) /* ignore single comma */
7983 continue;
7984 patlen = (int)(endpat - pat);
7985
7986 /*
7987 * detect special <buflocal[=X]> buffer-local patterns
7988 */
7989 is_buflocal = FALSE;
7990 buflocal_nr = 0;
7991
7992 if (patlen >= 7 && STRNCMP(pat, "<buffer", 7) == 0
7993 && pat[patlen - 1] == '>')
7994 {
7995 /* Error will be printed only for addition. printing and removing
7996 * will proceed silently. */
7997 is_buflocal = TRUE;
7998 if (patlen == 8)
7999 buflocal_nr = curbuf->b_fnum;
8000 else if (patlen > 9 && pat[7] == '=')
8001 {
8002 /* <buffer=abuf> */
8003 if (patlen == 13 && STRNICMP(pat, "<buffer=abuf>", 13))
8004 buflocal_nr = autocmd_bufnr;
8005 /* <buffer=123> */
8006 else if (skipdigits(pat + 8) == pat + patlen - 1)
8007 buflocal_nr = atoi((char *)pat + 8);
8008 }
8009 }
8010
8011 if (is_buflocal)
8012 {
8013 /* normalize pat into standard "<buffer>#N" form */
8014 sprintf((char *)buflocal_pat, "<buffer=%d>", buflocal_nr);
8015 pat = buflocal_pat; /* can modify pat and patlen */
8016 patlen = (int)STRLEN(buflocal_pat); /* but not endpat */
8017 }
8018
8019 /*
8020 * Find AutoPat entries with this pattern.
8021 */
8022 prev_ap = &first_autopat[(int)event];
8023 while ((ap = *prev_ap) != NULL)
8024 {
8025 if (ap->pat != NULL)
8026 {
8027 /* Accept a pattern when:
8028 * - a group was specified and it's that group, or a group was
8029 * not specified and it's the current group, or a group was
8030 * not specified and we are listing
8031 * - the length of the pattern matches
8032 * - the pattern matches.
8033 * For <buffer[=X]>, this condition works because we normalize
8034 * all buffer-local patterns.
8035 */
8036 if ((allgroups || ap->group == findgroup)
8037 && ap->patlen == patlen
8038 && STRNCMP(pat, ap->pat, patlen) == 0)
8039 {
8040 /*
8041 * Remove existing autocommands.
8042 * If adding any new autocmd's for this AutoPat, don't
8043 * delete the pattern from the autopat list, append to
8044 * this list.
8045 */
8046 if (forceit)
8047 {
8048 if (*cmd != NUL && ap->next == NULL)
8049 {
8050 au_remove_cmds(ap);
8051 break;
8052 }
8053 au_remove_pat(ap);
8054 }
8055
8056 /*
8057 * Show autocmd's for this autopat, or buflocals <buffer=X>
8058 */
8059 else if (*cmd == NUL)
8060 show_autocmd(ap, event);
8061
8062 /*
8063 * Add autocmd to this autopat, if it's the last one.
8064 */
8065 else if (ap->next == NULL)
8066 break;
8067 }
8068 }
8069 prev_ap = &ap->next;
8070 }
8071
8072 /*
8073 * Add a new command.
8074 */
8075 if (*cmd != NUL)
8076 {
8077 /*
8078 * If the pattern we want to add a command to does appear at the
8079 * end of the list (or not is not in the list at all), add the
8080 * pattern at the end of the list.
8081 */
8082 if (ap == NULL)
8083 {
8084 /* refuse to add buffer-local ap if buffer number is invalid */
8085 if (is_buflocal && (buflocal_nr == 0
8086 || buflist_findnr(buflocal_nr) == NULL))
8087 {
8088 EMSGN(_("E680: <buffer=%d>: invalid buffer number "),
8089 buflocal_nr);
8090 return FAIL;
8091 }
8092
8093 ap = (AutoPat *)alloc((unsigned)sizeof(AutoPat));
8094 if (ap == NULL)
8095 return FAIL;
8096 ap->pat = vim_strnsave(pat, patlen);
8097 ap->patlen = patlen;
8098 if (ap->pat == NULL)
8099 {
8100 vim_free(ap);
8101 return FAIL;
8102 }
8103
8104 if (is_buflocal)
8105 {
8106 ap->buflocal_nr = buflocal_nr;
8107 ap->reg_prog = NULL;
8108 }
8109 else
8110 {
8111 char_u *reg_pat;
8112
8113 ap->buflocal_nr = 0;
8114 reg_pat = file_pat_to_reg_pat(pat, endpat,
8115 &ap->allow_dirs, TRUE);
8116 if (reg_pat != NULL)
8117 ap->reg_prog = vim_regcomp(reg_pat, RE_MAGIC);
8118 vim_free(reg_pat);
8119 if (reg_pat == NULL || ap->reg_prog == NULL)
8120 {
8121 vim_free(ap->pat);
8122 vim_free(ap);
8123 return FAIL;
8124 }
8125 }
8126 ap->cmds = NULL;
8127 *prev_ap = ap;
8128 ap->next = NULL;
8129 if (group == AUGROUP_ALL)
8130 ap->group = current_augroup;
8131 else
8132 ap->group = group;
8133 }
8134
8135 /*
8136 * Add the autocmd at the end of the AutoCmd list.
8137 */
8138 prev_ac = &(ap->cmds);
8139 while ((ac = *prev_ac) != NULL)
8140 prev_ac = &ac->next;
8141 ac = (AutoCmd *)alloc((unsigned)sizeof(AutoCmd));
8142 if (ac == NULL)
8143 return FAIL;
8144 ac->cmd = vim_strsave(cmd);
8145 #ifdef FEAT_EVAL
8146 ac->scriptID = current_SID;
8147 #endif
8148 if (ac->cmd == NULL)
8149 {
8150 vim_free(ac);
8151 return FAIL;
8152 }
8153 ac->next = NULL;
8154 *prev_ac = ac;
8155 ac->nested = nested;
8156 }
8157 }
8158
8159 au_cleanup(); /* may really delete removed patterns/commands now */
8160 return OK;
8161 }
8162
8163 /*
8164 * Implementation of ":doautocmd [group] event [fname]".
8165 * Return OK for success, FAIL for failure;
8166 */
8167 int
8168 do_doautocmd(arg, do_msg)
8169 char_u *arg;
8170 int do_msg; /* give message for no matching autocmds? */
8171 {
8172 char_u *fname;
8173 int nothing_done = TRUE;
8174 int group;
8175
8176 /*
8177 * Check for a legal group name. If not, use AUGROUP_ALL.
8178 */
8179 group = au_get_grouparg(&arg);
8180 if (arg == NULL) /* out of memory */
8181 return FAIL;
8182
8183 if (*arg == '*')
8184 {
8185 EMSG(_("E217: Can't execute autocommands for ALL events"));
8186 return FAIL;
8187 }
8188
8189 /*
8190 * Scan over the events.
8191 * If we find an illegal name, return here, don't do anything.
8192 */
8193 fname = find_end_event(arg, group != AUGROUP_ALL);
8194 if (fname == NULL)
8195 return FAIL;
8196
8197 fname = skipwhite(fname);
8198
8199 /*
8200 * Loop over the events.
8201 */
8202 while (*arg && !vim_iswhite(*arg))
8203 if (apply_autocmds_group(event_name2nr(arg, &arg),
8204 fname, NULL, TRUE, group, curbuf, NULL))
8205 nothing_done = FALSE;
8206
8207 if (nothing_done && do_msg)
8208 MSG(_("No matching autocommands"));
8209
8210 #ifdef FEAT_EVAL
8211 return aborting() ? FAIL : OK;
8212 #else
8213 return OK;
8214 #endif
8215 }
8216
8217 /*
8218 * ":doautoall": execute autocommands for each loaded buffer.
8219 */
8220 void
8221 ex_doautoall(eap)
8222 exarg_T *eap;
8223 {
8224 int retval;
8225 aco_save_T aco;
8226 buf_T *buf;
8227
8228 /*
8229 * This is a bit tricky: For some commands curwin->w_buffer needs to be
8230 * equal to curbuf, but for some buffers there may not be a window.
8231 * So we change the buffer for the current window for a moment. This
8232 * gives problems when the autocommands make changes to the list of
8233 * buffers or windows...
8234 */
8235 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
8236 {
8237 if (buf->b_ml.ml_mfp != NULL)
8238 {
8239 /* find a window for this buffer and save some values */
8240 aucmd_prepbuf(&aco, buf);
8241
8242 /* execute the autocommands for this buffer */
8243 retval = do_doautocmd(eap->arg, FALSE);
8244
8245 /* Execute the modeline settings, but don't set window-local
8246 * options if we are using the current window for another buffer. */
8247 do_modelines(aco.save_curwin == NULL ? OPT_NOWIN : 0);
8248
8249 /* restore the current window */
8250 aucmd_restbuf(&aco);
8251
8252 /* stop if there is some error or buffer was deleted */
8253 if (retval == FAIL || !buf_valid(buf))
8254 break;
8255 }
8256 }
8257
8258 check_cursor(); /* just in case lines got deleted */
8259 }
8260
8261 /*
8262 * Prepare for executing autocommands for (hidden) buffer "buf".
8263 * Search a window for the current buffer. Save the cursor position and
8264 * screen offset.
8265 * Set "curbuf" and "curwin" to match "buf".
8266 * When FEAT_AUTOCMD is not defined another version is used, see below.
8267 */
8268 void
8269 aucmd_prepbuf(aco, buf)
8270 aco_save_T *aco; /* structure to save values in */
8271 buf_T *buf; /* new curbuf */
8272 {
8273 win_T *win;
8274
8275 aco->new_curbuf = buf;
8276
8277 /* Find a window that is for the new buffer */
8278 if (buf == curbuf) /* be quick when buf is curbuf */
8279 win = curwin;
8280 else
8281 #ifdef FEAT_WINDOWS
8282 for (win = firstwin; win != NULL; win = win->w_next)
8283 if (win->w_buffer == buf)
8284 break;
8285 #else
8286 win = NULL;
8287 #endif
8288
8289 /*
8290 * Prefer to use an existing window for the buffer, it has the least side
8291 * effects (esp. if "buf" is curbuf).
8292 * Otherwise, use curwin for "buf". It might make some items in the
8293 * window invalid. At least save the cursor and topline.
8294 */
8295 if (win != NULL)
8296 {
8297 /* there is a window for "buf", make it the curwin */
8298 aco->save_curwin = curwin;
8299 curwin = win;
8300 aco->save_buf = win->w_buffer;
8301 aco->new_curwin = win;
8302 }
8303 else
8304 {
8305 /* there is no window for "buf", use curwin */
8306 aco->save_curwin = NULL;
8307 aco->save_buf = curbuf;
8308 --curbuf->b_nwindows;
8309 curwin->w_buffer = buf;
8310 ++buf->b_nwindows;
8311
8312 /* save cursor and topline, set them to safe values */
8313 aco->save_cursor = curwin->w_cursor;
8314 curwin->w_cursor.lnum = 1;
8315 curwin->w_cursor.col = 0;
8316 aco->save_topline = curwin->w_topline;
8317 curwin->w_topline = 1;
8318 #ifdef FEAT_DIFF
8319 aco->save_topfill = curwin->w_topfill;
8320 curwin->w_topfill = 0;
8321 #endif
8322 }
8323
8324 curbuf = buf;
8325 }
8326
8327 /*
8328 * Cleanup after executing autocommands for a (hidden) buffer.
8329 * Restore the window as it was (if possible).
8330 * When FEAT_AUTOCMD is not defined another version is used, see below.
8331 */
8332 void
8333 aucmd_restbuf(aco)
8334 aco_save_T *aco; /* structure holding saved values */
8335 {
8336 if (aco->save_curwin != NULL)
8337 {
8338 /* restore curwin */
8339 #ifdef FEAT_WINDOWS
8340 if (win_valid(aco->save_curwin))
8341 #endif
8342 {
8343 /* restore the buffer which was previously edited by curwin, if
8344 * it's still the same window and it's valid */
8345 if (curwin == aco->new_curwin
8346 && buf_valid(aco->save_buf)
8347 && aco->save_buf->b_ml.ml_mfp != NULL)
8348 {
8349 --curbuf->b_nwindows;
8350 curbuf = aco->save_buf;
8351 curwin->w_buffer = curbuf;
8352 ++curbuf->b_nwindows;
8353 }
8354
8355 curwin = aco->save_curwin;
8356 curbuf = curwin->w_buffer;
8357 }
8358 }
8359 else
8360 {
8361 /* restore buffer for curwin if it still exists and is loaded */
8362 if (buf_valid(aco->save_buf) && aco->save_buf->b_ml.ml_mfp != NULL)
8363 {
8364 --curbuf->b_nwindows;
8365 curbuf = aco->save_buf;
8366 curwin->w_buffer = curbuf;
8367 ++curbuf->b_nwindows;
8368 curwin->w_cursor = aco->save_cursor;
8369 check_cursor();
8370 /* check topline < line_count, in case lines got deleted */
8371 if (aco->save_topline <= curbuf->b_ml.ml_line_count)
8372 {
8373 curwin->w_topline = aco->save_topline;
8374 #ifdef FEAT_DIFF
8375 curwin->w_topfill = aco->save_topfill;
8376 #endif
8377 }
8378 else
8379 {
8380 curwin->w_topline = curbuf->b_ml.ml_line_count;
8381 #ifdef FEAT_DIFF
8382 curwin->w_topfill = 0;
8383 #endif
8384 }
8385 }
8386 }
8387 }
8388
8389 static int autocmd_nested = FALSE;
8390
8391 /*
8392 * Execute autocommands for "event" and file name "fname".
8393 * Return TRUE if some commands were executed.
8394 */
8395 int
8396 apply_autocmds(event, fname, fname_io, force, buf)
8397 event_T event;
8398 char_u *fname; /* NULL or empty means use actual file name */
8399 char_u *fname_io; /* fname to use for <afile> on cmdline */
8400 int force; /* when TRUE, ignore autocmd_busy */
8401 buf_T *buf; /* buffer for <abuf> */
8402 {
8403 return apply_autocmds_group(event, fname, fname_io, force,
8404 AUGROUP_ALL, buf, NULL);
8405 }
8406
8407 /*
8408 * Like apply_autocmds(), but with extra "eap" argument. This takes care of
8409 * setting v:filearg.
8410 */
8411 static int
8412 apply_autocmds_exarg(event, fname, fname_io, force, buf, eap)
8413 event_T event;
8414 char_u *fname;
8415 char_u *fname_io;
8416 int force;
8417 buf_T *buf;
8418 exarg_T *eap;
8419 {
8420 return apply_autocmds_group(event, fname, fname_io, force,
8421 AUGROUP_ALL, buf, eap);
8422 }
8423
8424 /*
8425 * Like apply_autocmds(), but handles the caller's retval. If the script
8426 * processing is being aborted or if retval is FAIL when inside a try
8427 * conditional, no autocommands are executed. If otherwise the autocommands
8428 * cause the script to be aborted, retval is set to FAIL.
8429 */
8430 int
8431 apply_autocmds_retval(event, fname, fname_io, force, buf, retval)
8432 event_T event;
8433 char_u *fname; /* NULL or empty means use actual file name */
8434 char_u *fname_io; /* fname to use for <afile> on cmdline */
8435 int force; /* when TRUE, ignore autocmd_busy */
8436 buf_T *buf; /* buffer for <abuf> */
8437 int *retval; /* pointer to caller's retval */
8438 {
8439 int did_cmd;
8440
8441 #ifdef FEAT_EVAL
8442 if (should_abort(*retval))
8443 return FALSE;
8444 #endif
8445
8446 did_cmd = apply_autocmds_group(event, fname, fname_io, force,
8447 AUGROUP_ALL, buf, NULL);
8448 if (did_cmd
8449 #ifdef FEAT_EVAL
8450 && aborting()
8451 #endif
8452 )
8453 *retval = FAIL;
8454 return did_cmd;
8455 }
8456
8457 /*
8458 * Return TRUE when there is a CursorHold autocommand defined.
8459 */
8460 int
8461 has_cursorhold()
8462 {
8463 return (first_autopat[(int)(get_real_state() == NORMAL_BUSY
8464 ? EVENT_CURSORHOLD : EVENT_CURSORHOLDI)] != NULL);
8465 }
8466
8467 /*
8468 * Return TRUE if the CursorHold event can be triggered.
8469 */
8470 int
8471 trigger_cursorhold()
8472 {
8473 int state;
8474
8475 if (!did_cursorhold && has_cursorhold() && !Recording
8476 #ifdef FEAT_INS_EXPAND
8477 && !ins_compl_active()
8478 #endif
8479 )
8480 {
8481 state = get_real_state();
8482 if (state == NORMAL_BUSY || (state & INSERT) != 0)
8483 return TRUE;
8484 }
8485 return FALSE;
8486 }
8487
8488 /*
8489 * Return TRUE when there is a CursorMoved autocommand defined.
8490 */
8491 int
8492 has_cursormoved()
8493 {
8494 return (first_autopat[(int)EVENT_CURSORMOVED] != NULL);
8495 }
8496
8497 /*
8498 * Return TRUE when there is a CursorMovedI autocommand defined.
8499 */
8500 int
8501 has_cursormovedI()
8502 {
8503 return (first_autopat[(int)EVENT_CURSORMOVEDI] != NULL);
8504 }
8505
8506 static int
8507 apply_autocmds_group(event, fname, fname_io, force, group, buf, eap)
8508 event_T event;
8509 char_u *fname; /* NULL or empty means use actual file name */
8510 char_u *fname_io; /* fname to use for <afile> on cmdline, NULL means
8511 use fname */
8512 int force; /* when TRUE, ignore autocmd_busy */
8513 int group; /* group ID, or AUGROUP_ALL */
8514 buf_T *buf; /* buffer for <abuf> */
8515 exarg_T *eap; /* command arguments */
8516 {
8517 char_u *sfname = NULL; /* short file name */
8518 char_u *tail;
8519 int save_changed;
8520 buf_T *old_curbuf;
8521 int retval = FALSE;
8522 char_u *save_sourcing_name;
8523 linenr_T save_sourcing_lnum;
8524 char_u *save_autocmd_fname;
8525 int save_autocmd_fname_full;
8526 int save_autocmd_bufnr;
8527 char_u *save_autocmd_match;
8528 int save_autocmd_busy;
8529 int save_autocmd_nested;
8530 static int nesting = 0;
8531 AutoPatCmd patcmd;
8532 AutoPat *ap;
8533 #ifdef FEAT_EVAL
8534 scid_T save_current_SID;
8535 void *save_funccalp;
8536 char_u *save_cmdarg;
8537 long save_cmdbang;
8538 #endif
8539 static int filechangeshell_busy = FALSE;
8540 #ifdef FEAT_PROFILE
8541 proftime_T wait_time;
8542 #endif
8543
8544 /*
8545 * Quickly return if there are no autocommands for this event or
8546 * autocommands are blocked.
8547 */
8548 if (first_autopat[(int)event] == NULL || autocmd_blocked > 0)
8549 goto BYPASS_AU;
8550
8551 /*
8552 * When autocommands are busy, new autocommands are only executed when
8553 * explicitly enabled with the "nested" flag.
8554 */
8555 if (autocmd_busy && !(force || autocmd_nested))
8556 goto BYPASS_AU;
8557
8558 #ifdef FEAT_EVAL
8559 /*
8560 * Quickly return when immediately aborting on error, or when an interrupt
8561 * occurred or an exception was thrown but not caught.
8562 */
8563 if (aborting())
8564 goto BYPASS_AU;
8565 #endif
8566
8567 /*
8568 * FileChangedShell never nests, because it can create an endless loop.
8569 */
8570 if (filechangeshell_busy && (event == EVENT_FILECHANGEDSHELL
8571 || event == EVENT_FILECHANGEDSHELLPOST))
8572 goto BYPASS_AU;
8573
8574 /*
8575 * Ignore events in 'eventignore'.
8576 */
8577 if (event_ignored(event))
8578 goto BYPASS_AU;
8579
8580 /*
8581 * Allow nesting of autocommands, but restrict the depth, because it's
8582 * possible to create an endless loop.
8583 */
8584 if (nesting == 10)
8585 {
8586 EMSG(_("E218: autocommand nesting too deep"));
8587 goto BYPASS_AU;
8588 }
8589
8590 /*
8591 * Check if these autocommands are disabled. Used when doing ":all" or
8592 * ":ball".
8593 */
8594 if ( (autocmd_no_enter
8595 && (event == EVENT_WINENTER || event == EVENT_BUFENTER))
8596 || (autocmd_no_leave
8597 && (event == EVENT_WINLEAVE || event == EVENT_BUFLEAVE)))
8598 goto BYPASS_AU;
8599
8600 /*
8601 * Save the autocmd_* variables and info about the current buffer.
8602 */
8603 save_autocmd_fname = autocmd_fname;
8604 save_autocmd_fname_full = autocmd_fname_full;
8605 save_autocmd_bufnr = autocmd_bufnr;
8606 save_autocmd_match = autocmd_match;
8607 save_autocmd_busy = autocmd_busy;
8608 save_autocmd_nested = autocmd_nested;
8609 save_changed = curbuf->b_changed;
8610 old_curbuf = curbuf;
8611
8612 /*
8613 * Set the file name to be used for <afile>.
8614 * Make a copy to avoid that changing a buffer name or directory makes it
8615 * invalid.
8616 */
8617 if (fname_io == NULL)
8618 {
8619 if (fname != NULL && *fname != NUL)
8620 autocmd_fname = fname;
8621 else if (buf != NULL)
8622 autocmd_fname = buf->b_ffname;
8623 else
8624 autocmd_fname = NULL;
8625 }
8626 else
8627 autocmd_fname = fname_io;
8628 if (autocmd_fname != NULL)
8629 autocmd_fname = vim_strsave(autocmd_fname);
8630 autocmd_fname_full = FALSE; /* call FullName_save() later */
8631
8632 /*
8633 * Set the buffer number to be used for <abuf>.
8634 */
8635 if (buf == NULL)
8636 autocmd_bufnr = 0;
8637 else
8638 autocmd_bufnr = buf->b_fnum;
8639
8640 /*
8641 * When the file name is NULL or empty, use the file name of buffer "buf".
8642 * Always use the full path of the file name to match with, in case
8643 * "allow_dirs" is set.
8644 */
8645 if (fname == NULL || *fname == NUL)
8646 {
8647 if (buf == NULL)
8648 fname = NULL;
8649 else
8650 {
8651 #ifdef FEAT_SYN_HL
8652 if (event == EVENT_SYNTAX)
8653 fname = buf->b_p_syn;
8654 else
8655 #endif
8656 if (event == EVENT_FILETYPE)
8657 fname = buf->b_p_ft;
8658 else
8659 {
8660 if (buf->b_sfname != NULL)
8661 sfname = vim_strsave(buf->b_sfname);
8662 fname = buf->b_ffname;
8663 }
8664 }
8665 if (fname == NULL)
8666 fname = (char_u *)"";
8667 fname = vim_strsave(fname); /* make a copy, so we can change it */
8668 }
8669 else
8670 {
8671 sfname = vim_strsave(fname);
8672 /* Don't try expanding FileType, Syntax, WindowID or QuickFixCmd* */
8673 if (event == EVENT_FILETYPE
8674 || event == EVENT_SYNTAX
8675 || event == EVENT_REMOTEREPLY
8676 || event == EVENT_SPELLFILEMISSING
8677 || event == EVENT_QUICKFIXCMDPRE
8678 || event == EVENT_QUICKFIXCMDPOST)
8679 fname = vim_strsave(fname);
8680 else
8681 fname = FullName_save(fname, FALSE);
8682 }
8683 if (fname == NULL) /* out of memory */
8684 {
8685 vim_free(sfname);
8686 retval = FALSE;
8687 goto BYPASS_AU;
8688 }
8689
8690 #ifdef BACKSLASH_IN_FILENAME
8691 /*
8692 * Replace all backslashes with forward slashes. This makes the
8693 * autocommand patterns portable between Unix and MS-DOS.
8694 */
8695 if (sfname != NULL)
8696 forward_slash(sfname);
8697 forward_slash(fname);
8698 #endif
8699
8700 #ifdef VMS
8701 /* remove version for correct match */
8702 if (sfname != NULL)
8703 vms_remove_version(sfname);
8704 vms_remove_version(fname);
8705 #endif
8706
8707 /*
8708 * Set the name to be used for <amatch>.
8709 */
8710 autocmd_match = fname;
8711
8712
8713 /* Don't redraw while doing auto commands. */
8714 ++RedrawingDisabled;
8715 save_sourcing_name = sourcing_name;
8716 sourcing_name = NULL; /* don't free this one */
8717 save_sourcing_lnum = sourcing_lnum;
8718 sourcing_lnum = 0; /* no line number here */
8719
8720 #ifdef FEAT_EVAL
8721 save_current_SID = current_SID;
8722
8723 # ifdef FEAT_PROFILE
8724 if (do_profiling == PROF_YES)
8725 prof_child_enter(&wait_time); /* doesn't count for the caller itself */
8726 # endif
8727
8728 /* Don't use local function variables, if called from a function */
8729 save_funccalp = save_funccal();
8730 #endif
8731
8732 /*
8733 * When starting to execute autocommands, save the search patterns.
8734 */
8735 if (!autocmd_busy)
8736 {
8737 save_search_patterns();
8738 saveRedobuff();
8739 did_filetype = keep_filetype;
8740 }
8741
8742 /*
8743 * Note that we are applying autocmds. Some commands need to know.
8744 */
8745 autocmd_busy = TRUE;
8746 filechangeshell_busy = (event == EVENT_FILECHANGEDSHELL);
8747 ++nesting; /* see matching decrement below */
8748
8749 /* Remember that FileType was triggered. Used for did_filetype(). */
8750 if (event == EVENT_FILETYPE)
8751 did_filetype = TRUE;
8752
8753 tail = gettail(fname);
8754
8755 /* Find first autocommand that matches */
8756 patcmd.curpat = first_autopat[(int)event];
8757 patcmd.nextcmd = NULL;
8758 patcmd.group = group;
8759 patcmd.fname = fname;
8760 patcmd.sfname = sfname;
8761 patcmd.tail = tail;
8762 patcmd.event = event;
8763 patcmd.arg_bufnr = autocmd_bufnr;
8764 patcmd.next = NULL;
8765 auto_next_pat(&patcmd, FALSE);
8766
8767 /* found one, start executing the autocommands */
8768 if (patcmd.curpat != NULL)
8769 {
8770 /* add to active_apc_list */
8771 patcmd.next = active_apc_list;
8772 active_apc_list = &patcmd;
8773
8774 #ifdef FEAT_EVAL
8775 /* set v:cmdarg (only when there is a matching pattern) */
8776 save_cmdbang = get_vim_var_nr(VV_CMDBANG);
8777 if (eap != NULL)
8778 {
8779 save_cmdarg = set_cmdarg(eap, NULL);
8780 set_vim_var_nr(VV_CMDBANG, (long)eap->forceit);
8781 }
8782 else
8783 save_cmdarg = NULL; /* avoid gcc warning */
8784 #endif
8785 retval = TRUE;
8786 /* mark the last pattern, to avoid an endless loop when more patterns
8787 * are added when executing autocommands */
8788 for (ap = patcmd.curpat; ap->next != NULL; ap = ap->next)
8789 ap->last = FALSE;
8790 ap->last = TRUE;
8791 check_lnums(TRUE); /* make sure cursor and topline are valid */
8792 do_cmdline(NULL, getnextac, (void *)&patcmd,
8793 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT);
8794 #ifdef FEAT_EVAL
8795 if (eap != NULL)
8796 {
8797 (void)set_cmdarg(NULL, save_cmdarg);
8798 set_vim_var_nr(VV_CMDBANG, save_cmdbang);
8799 }
8800 #endif
8801 /* delete from active_apc_list */
8802 if (active_apc_list == &patcmd) /* just in case */
8803 active_apc_list = patcmd.next;
8804 }
8805
8806 --RedrawingDisabled;
8807 autocmd_busy = save_autocmd_busy;
8808 filechangeshell_busy = FALSE;
8809 autocmd_nested = save_autocmd_nested;
8810 vim_free(sourcing_name);
8811 sourcing_name = save_sourcing_name;
8812 sourcing_lnum = save_sourcing_lnum;
8813 vim_free(autocmd_fname);
8814 autocmd_fname = save_autocmd_fname;
8815 autocmd_fname_full = save_autocmd_fname_full;
8816 autocmd_bufnr = save_autocmd_bufnr;
8817 autocmd_match = save_autocmd_match;
8818 #ifdef FEAT_EVAL
8819 current_SID = save_current_SID;
8820 restore_funccal(save_funccalp);
8821 # ifdef FEAT_PROFILE
8822 if (do_profiling == PROF_YES)
8823 prof_child_exit(&wait_time);
8824 # endif
8825 #endif
8826 vim_free(fname);
8827 vim_free(sfname);
8828 --nesting; /* see matching increment above */
8829
8830 /*
8831 * When stopping to execute autocommands, restore the search patterns and
8832 * the redo buffer.
8833 */
8834 if (!autocmd_busy)
8835 {
8836 restore_search_patterns();
8837 restoreRedobuff();
8838 did_filetype = FALSE;
8839 }
8840
8841 /*
8842 * Some events don't set or reset the Changed flag.
8843 * Check if still in the same buffer!
8844 */
8845 if (curbuf == old_curbuf
8846 && (event == EVENT_BUFREADPOST
8847 || event == EVENT_BUFWRITEPOST
8848 || event == EVENT_FILEAPPENDPOST
8849 || event == EVENT_VIMLEAVE
8850 || event == EVENT_VIMLEAVEPRE))
8851 {
8852 #ifdef FEAT_TITLE
8853 if (curbuf->b_changed != save_changed)
8854 need_maketitle = TRUE;
8855 #endif
8856 curbuf->b_changed = save_changed;
8857 }
8858
8859 au_cleanup(); /* may really delete removed patterns/commands now */
8860
8861 BYPASS_AU:
8862 /* When wiping out a buffer make sure all its buffer-local autocommands
8863 * are deleted. */
8864 if (event == EVENT_BUFWIPEOUT && buf != NULL)
8865 aubuflocal_remove(buf);
8866
8867 return retval;
8868 }
8869
8870 # ifdef FEAT_EVAL
8871 static char_u *old_termresponse = NULL;
8872 # endif
8873
8874 /*
8875 * Block triggering autocommands until unblock_autocmd() is called.
8876 * Can be used recursively, so long as it's symmetric.
8877 */
8878 void
8879 block_autocmds()
8880 {
8881 # ifdef FEAT_EVAL
8882 /* Remember the value of v:termresponse. */
8883 if (autocmd_blocked == 0)
8884 old_termresponse = get_vim_var_str(VV_TERMRESPONSE);
8885 # endif
8886 ++autocmd_blocked;
8887 }
8888
8889 void
8890 unblock_autocmds()
8891 {
8892 --autocmd_blocked;
8893
8894 # ifdef FEAT_EVAL
8895 /* When v:termresponse was set while autocommands were blocked, trigger
8896 * the autocommands now. Esp. useful when executing a shell command
8897 * during startup (vimdiff). */
8898 if (autocmd_blocked == 0
8899 && get_vim_var_str(VV_TERMRESPONSE) != old_termresponse)
8900 apply_autocmds(EVENT_TERMRESPONSE, NULL, NULL, FALSE, curbuf);
8901 # endif
8902 }
8903
8904 /*
8905 * Find next autocommand pattern that matches.
8906 */
8907 static void
8908 auto_next_pat(apc, stop_at_last)
8909 AutoPatCmd *apc;
8910 int stop_at_last; /* stop when 'last' flag is set */
8911 {
8912 AutoPat *ap;
8913 AutoCmd *cp;
8914 char_u *name;
8915 char *s;
8916
8917 vim_free(sourcing_name);
8918 sourcing_name = NULL;
8919
8920 for (ap = apc->curpat; ap != NULL && !got_int; ap = ap->next)
8921 {
8922 apc->curpat = NULL;
8923
8924 /* Only use a pattern when it has not been removed, has commands and
8925 * the group matches. For buffer-local autocommands only check the
8926 * buffer number. */
8927 if (ap->pat != NULL && ap->cmds != NULL
8928 && (apc->group == AUGROUP_ALL || apc->group == ap->group))
8929 {
8930 /* execution-condition */
8931 if (ap->buflocal_nr == 0
8932 ? (match_file_pat(NULL, ap->reg_prog, apc->fname,
8933 apc->sfname, apc->tail, ap->allow_dirs))
8934 : ap->buflocal_nr == apc->arg_bufnr)
8935 {
8936 name = event_nr2name(apc->event);
8937 s = _("%s Auto commands for \"%s\"");
8938 sourcing_name = alloc((unsigned)(STRLEN(s)
8939 + STRLEN(name) + ap->patlen + 1));
8940 if (sourcing_name != NULL)
8941 {
8942 sprintf((char *)sourcing_name, s,
8943 (char *)name, (char *)ap->pat);
8944 if (p_verbose >= 8)
8945 {
8946 verbose_enter();
8947 smsg((char_u *)_("Executing %s"), sourcing_name);
8948 verbose_leave();
8949 }
8950 }
8951
8952 apc->curpat = ap;
8953 apc->nextcmd = ap->cmds;
8954 /* mark last command */
8955 for (cp = ap->cmds; cp->next != NULL; cp = cp->next)
8956 cp->last = FALSE;
8957 cp->last = TRUE;
8958 }
8959 line_breakcheck();
8960 if (apc->curpat != NULL) /* found a match */
8961 break;
8962 }
8963 if (stop_at_last && ap->last)
8964 break;
8965 }
8966 }
8967
8968 /*
8969 * Get next autocommand command.
8970 * Called by do_cmdline() to get the next line for ":if".
8971 * Returns allocated string, or NULL for end of autocommands.
8972 */
8973 /* ARGSUSED */
8974 static char_u *
8975 getnextac(c, cookie, indent)
8976 int c; /* not used */
8977 void *cookie;
8978 int indent; /* not used */
8979 {
8980 AutoPatCmd *acp = (AutoPatCmd *)cookie;
8981 char_u *retval;
8982 AutoCmd *ac;
8983
8984 /* Can be called again after returning the last line. */
8985 if (acp->curpat == NULL)
8986 return NULL;
8987
8988 /* repeat until we find an autocommand to execute */
8989 for (;;)
8990 {
8991 /* skip removed commands */
8992 while (acp->nextcmd != NULL && acp->nextcmd->cmd == NULL)
8993 if (acp->nextcmd->last)
8994 acp->nextcmd = NULL;
8995 else
8996 acp->nextcmd = acp->nextcmd->next;
8997
8998 if (acp->nextcmd != NULL)
8999 break;
9000
9001 /* at end of commands, find next pattern that matches */
9002 if (acp->curpat->last)
9003 acp->curpat = NULL;
9004 else
9005 acp->curpat = acp->curpat->next;
9006 if (acp->curpat != NULL)
9007 auto_next_pat(acp, TRUE);
9008 if (acp->curpat == NULL)
9009 return NULL;
9010 }
9011
9012 ac = acp->nextcmd;
9013
9014 if (p_verbose >= 9)
9015 {
9016 verbose_enter_scroll();
9017 smsg((char_u *)_("autocommand %s"), ac->cmd);
9018 msg_puts((char_u *)"\n"); /* don't overwrite this either */
9019 verbose_leave_scroll();
9020 }
9021 retval = vim_strsave(ac->cmd);
9022 autocmd_nested = ac->nested;
9023 #ifdef FEAT_EVAL
9024 current_SID = ac->scriptID;
9025 #endif
9026 if (ac->last)
9027 acp->nextcmd = NULL;
9028 else
9029 acp->nextcmd = ac->next;
9030 return retval;
9031 }
9032
9033 /*
9034 * Return TRUE if there is a matching autocommand for "fname".
9035 * To account for buffer-local autocommands, function needs to know
9036 * in which buffer the file will be opened.
9037 */
9038 int
9039 has_autocmd(event, sfname, buf)
9040 event_T event;
9041 char_u *sfname;
9042 buf_T *buf;
9043 {
9044 AutoPat *ap;
9045 char_u *fname;
9046 char_u *tail = gettail(sfname);
9047 int retval = FALSE;
9048
9049 fname = FullName_save(sfname, FALSE);
9050 if (fname == NULL)
9051 return FALSE;
9052
9053 #ifdef BACKSLASH_IN_FILENAME
9054 /*
9055 * Replace all backslashes with forward slashes. This makes the
9056 * autocommand patterns portable between Unix and MS-DOS.
9057 */
9058 sfname = vim_strsave(sfname);
9059 if (sfname != NULL)
9060 forward_slash(sfname);
9061 forward_slash(fname);
9062 #endif
9063
9064 for (ap = first_autopat[(int)event]; ap != NULL; ap = ap->next)
9065 if (ap->pat != NULL && ap->cmds != NULL
9066 && (ap->buflocal_nr == 0
9067 ? match_file_pat(NULL, ap->reg_prog,
9068 fname, sfname, tail, ap->allow_dirs)
9069 : buf != NULL && ap->buflocal_nr == buf->b_fnum
9070 ))
9071 {
9072 retval = TRUE;
9073 break;
9074 }
9075
9076 vim_free(fname);
9077 #ifdef BACKSLASH_IN_FILENAME
9078 vim_free(sfname);
9079 #endif
9080
9081 return retval;
9082 }
9083
9084 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
9085 /*
9086 * Function given to ExpandGeneric() to obtain the list of autocommand group
9087 * names.
9088 */
9089 /*ARGSUSED*/
9090 char_u *
9091 get_augroup_name(xp, idx)
9092 expand_T *xp;
9093 int idx;
9094 {
9095 if (idx == augroups.ga_len) /* add "END" add the end */
9096 return (char_u *)"END";
9097 if (idx >= augroups.ga_len) /* end of list */
9098 return NULL;
9099 if (AUGROUP_NAME(idx) == NULL) /* skip deleted entries */
9100 return (char_u *)"";
9101 return AUGROUP_NAME(idx); /* return a name */
9102 }
9103
9104 static int include_groups = FALSE;
9105
9106 char_u *
9107 set_context_in_autocmd(xp, arg, doautocmd)
9108 expand_T *xp;
9109 char_u *arg;
9110 int doautocmd; /* TRUE for :doauto*, FALSE for :autocmd */
9111 {
9112 char_u *p;
9113 int group;
9114
9115 /* check for a group name, skip it if present */
9116 include_groups = FALSE;
9117 p = arg;
9118 group = au_get_grouparg(&arg);
9119 if (group == AUGROUP_ERROR)
9120 return NULL;
9121 /* If there only is a group name that's what we expand. */
9122 if (*arg == NUL && group != AUGROUP_ALL && !vim_iswhite(arg[-1]))
9123 {
9124 arg = p;
9125 group = AUGROUP_ALL;
9126 }
9127
9128 /* skip over event name */
9129 for (p = arg; *p != NUL && !vim_iswhite(*p); ++p)
9130 if (*p == ',')
9131 arg = p + 1;
9132 if (*p == NUL)
9133 {
9134 if (group == AUGROUP_ALL)
9135 include_groups = TRUE;
9136 xp->xp_context = EXPAND_EVENTS; /* expand event name */
9137 xp->xp_pattern = arg;
9138 return NULL;
9139 }
9140
9141 /* skip over pattern */
9142 arg = skipwhite(p);
9143 while (*arg && (!vim_iswhite(*arg) || arg[-1] == '\\'))
9144 arg++;
9145 if (*arg)
9146 return arg; /* expand (next) command */
9147
9148 if (doautocmd)
9149 xp->xp_context = EXPAND_FILES; /* expand file names */
9150 else
9151 xp->xp_context = EXPAND_NOTHING; /* pattern is not expanded */
9152 return NULL;
9153 }
9154
9155 /*
9156 * Function given to ExpandGeneric() to obtain the list of event names.
9157 */
9158 /*ARGSUSED*/
9159 char_u *
9160 get_event_name(xp, idx)
9161 expand_T *xp;
9162 int idx;
9163 {
9164 if (idx < augroups.ga_len) /* First list group names, if wanted */
9165 {
9166 if (!include_groups || AUGROUP_NAME(idx) == NULL)
9167 return (char_u *)""; /* skip deleted entries */
9168 return AUGROUP_NAME(idx); /* return a name */
9169 }
9170 return (char_u *)event_names[idx - augroups.ga_len].name;
9171 }
9172
9173 #endif /* FEAT_CMDL_COMPL */
9174
9175 /*
9176 * Return TRUE if autocmd is supported.
9177 */
9178 int
9179 autocmd_supported(name)
9180 char_u *name;
9181 {
9182 char_u *p;
9183
9184 return (event_name2nr(name, &p) != NUM_EVENTS);
9185 }
9186
9187 /*
9188 * Return TRUE if an autocommand is defined for a group, event and
9189 * pattern: The group can be omitted to accept any group. "event" and "pattern"
9190 * can be NULL to accept any event and pattern. "pattern" can be NULL to accept
9191 * any pattern. Buffer-local patterns <buffer> or <buffer=N> are accepted.
9192 * Used for:
9193 * exists("#Group") or
9194 * exists("#Group#Event") or
9195 * exists("#Group#Event#pat") or
9196 * exists("#Event") or
9197 * exists("#Event#pat")
9198 */
9199 int
9200 au_exists(arg)
9201 char_u *arg;
9202 {
9203 char_u *arg_save;
9204 char_u *pattern = NULL;
9205 char_u *event_name;
9206 char_u *p;
9207 event_T event;
9208 AutoPat *ap;
9209 buf_T *buflocal_buf = NULL;
9210 int group;
9211 int retval = FALSE;
9212
9213 /* Make a copy so that we can change the '#' chars to a NUL. */
9214 arg_save = vim_strsave(arg);
9215 if (arg_save == NULL)
9216 return FALSE;
9217 p = vim_strchr(arg_save, '#');
9218 if (p != NULL)
9219 *p++ = NUL;
9220
9221 /* First, look for an autocmd group name */
9222 group = au_find_group(arg_save);
9223 if (group == AUGROUP_ERROR)
9224 {
9225 /* Didn't match a group name, assume the first argument is an event. */
9226 group = AUGROUP_ALL;
9227 event_name = arg_save;
9228 }
9229 else
9230 {
9231 if (p == NULL)
9232 {
9233 /* "Group": group name is present and it's recognized */
9234 retval = TRUE;
9235 goto theend;
9236 }
9237
9238 /* Must be "Group#Event" or "Group#Event#pat". */
9239 event_name = p;
9240 p = vim_strchr(event_name, '#');
9241 if (p != NULL)
9242 *p++ = NUL; /* "Group#Event#pat" */
9243 }
9244
9245 pattern = p; /* "pattern" is NULL when there is no pattern */
9246
9247 /* find the index (enum) for the event name */
9248 event = event_name2nr(event_name, &p);
9249
9250 /* return FALSE if the event name is not recognized */
9251 if (event == NUM_EVENTS)
9252 goto theend;
9253
9254 /* Find the first autocommand for this event.
9255 * If there isn't any, return FALSE;
9256 * If there is one and no pattern given, return TRUE; */
9257 ap = first_autopat[(int)event];
9258 if (ap == NULL)
9259 goto theend;
9260 if (pattern == NULL)
9261 {
9262 retval = TRUE;
9263 goto theend;
9264 }
9265
9266 /* if pattern is "<buffer>", special handling is needed which uses curbuf */
9267 /* for pattern "<buffer=N>, fnamecmp() will work fine */
9268 if (STRICMP(pattern, "<buffer>") == 0)
9269 buflocal_buf = curbuf;
9270
9271 /* Check if there is an autocommand with the given pattern. */
9272 for ( ; ap != NULL; ap = ap->next)
9273 /* only use a pattern when it has not been removed and has commands. */
9274 /* For buffer-local autocommands, fnamecmp() works fine. */
9275 if (ap->pat != NULL && ap->cmds != NULL
9276 && (group == AUGROUP_ALL || ap->group == group)
9277 && (buflocal_buf == NULL
9278 ? fnamecmp(ap->pat, pattern) == 0
9279 : ap->buflocal_nr == buflocal_buf->b_fnum))
9280 {
9281 retval = TRUE;
9282 break;
9283 }
9284
9285 theend:
9286 vim_free(arg_save);
9287 return retval;
9288 }
9289
9290 #else /* FEAT_AUTOCMD */
9291
9292 /*
9293 * Prepare for executing commands for (hidden) buffer "buf".
9294 * This is the non-autocommand version, it simply saves "curbuf" and sets
9295 * "curbuf" and "curwin" to match "buf".
9296 */
9297 void
9298 aucmd_prepbuf(aco, buf)
9299 aco_save_T *aco; /* structure to save values in */
9300 buf_T *buf; /* new curbuf */
9301 {
9302 aco->save_buf = curbuf;
9303 curbuf = buf;
9304 curwin->w_buffer = buf;
9305 }
9306
9307 /*
9308 * Restore after executing commands for a (hidden) buffer.
9309 * This is the non-autocommand version.
9310 */
9311 void
9312 aucmd_restbuf(aco)
9313 aco_save_T *aco; /* structure holding saved values */
9314 {
9315 curbuf = aco->save_buf;
9316 curwin->w_buffer = curbuf;
9317 }
9318
9319 #endif /* FEAT_AUTOCMD */
9320
9321
9322 #if defined(FEAT_AUTOCMD) || defined(FEAT_WILDIGN) || defined(PROTO)
9323 /*
9324 * Try matching a filename with a "pattern" ("prog" is NULL), or use the
9325 * precompiled regprog "prog" ("pattern" is NULL). That avoids calling
9326 * vim_regcomp() often.
9327 * Used for autocommands and 'wildignore'.
9328 * Returns TRUE if there is a match, FALSE otherwise.
9329 */
9330 int
9331 match_file_pat(pattern, prog, fname, sfname, tail, allow_dirs)
9332 char_u *pattern; /* pattern to match with */
9333 regprog_T *prog; /* pre-compiled regprog or NULL */
9334 char_u *fname; /* full path of file name */
9335 char_u *sfname; /* short file name or NULL */
9336 char_u *tail; /* tail of path */
9337 int allow_dirs; /* allow matching with dir */
9338 {
9339 regmatch_T regmatch;
9340 int result = FALSE;
9341 #ifdef FEAT_OSFILETYPE
9342 int no_pattern = FALSE; /* TRUE if check is filetype only */
9343 char_u *type_start;
9344 char_u c;
9345 int match = FALSE;
9346 #endif
9347
9348 #ifdef CASE_INSENSITIVE_FILENAME
9349 regmatch.rm_ic = TRUE; /* Always ignore case */
9350 #else
9351 regmatch.rm_ic = FALSE; /* Don't ever ignore case */
9352 #endif
9353 #ifdef FEAT_OSFILETYPE
9354 if (*pattern == '<')
9355 {
9356 /* There is a filetype condition specified with this pattern.
9357 * Check the filetype matches first. If not, don't bother with the
9358 * pattern (set regprog to NULL).
9359 * Always use magic for the regexp.
9360 */
9361
9362 for (type_start = pattern + 1; (c = *pattern); pattern++)
9363 {
9364 if ((c == ';' || c == '>') && match == FALSE)
9365 {
9366 *pattern = NUL; /* Terminate the string */
9367 match = mch_check_filetype(fname, type_start);
9368 *pattern = c; /* Restore the terminator */
9369 type_start = pattern + 1;
9370 }
9371 if (c == '>')
9372 break;
9373 }
9374
9375 /* (c should never be NUL, but check anyway) */
9376 if (match == FALSE || c == NUL)
9377 regmatch.regprog = NULL; /* Doesn't match - don't check pat. */
9378 else if (*pattern == NUL)
9379 {
9380 regmatch.regprog = NULL; /* Vim will try to free regprog later */
9381 no_pattern = TRUE; /* Always matches - don't check pat. */
9382 }
9383 else
9384 regmatch.regprog = vim_regcomp(pattern + 1, RE_MAGIC);
9385 }
9386 else
9387 #endif
9388 {
9389 if (prog != NULL)
9390 regmatch.regprog = prog;
9391 else
9392 regmatch.regprog = vim_regcomp(pattern, RE_MAGIC);
9393 }
9394
9395 /*
9396 * Try for a match with the pattern with:
9397 * 1. the full file name, when the pattern has a '/'.
9398 * 2. the short file name, when the pattern has a '/'.
9399 * 3. the tail of the file name, when the pattern has no '/'.
9400 */
9401 if (
9402 #ifdef FEAT_OSFILETYPE
9403 /* If the check is for a filetype only and we don't care
9404 * about the path then skip all the regexp stuff.
9405 */
9406 no_pattern ||
9407 #endif
9408 (regmatch.regprog != NULL
9409 && ((allow_dirs
9410 && (vim_regexec(&regmatch, fname, (colnr_T)0)
9411 || (sfname != NULL
9412 && vim_regexec(&regmatch, sfname, (colnr_T)0))))
9413 || (!allow_dirs && vim_regexec(&regmatch, tail, (colnr_T)0)))))
9414 result = TRUE;
9415
9416 if (prog == NULL)
9417 vim_free(regmatch.regprog);
9418 return result;
9419 }
9420 #endif
9421
9422 #if defined(FEAT_WILDIGN) || defined(PROTO)
9423 /*
9424 * Return TRUE if a file matches with a pattern in "list".
9425 * "list" is a comma-separated list of patterns, like 'wildignore'.
9426 * "sfname" is the short file name or NULL, "ffname" the long file name.
9427 */
9428 int
9429 match_file_list(list, sfname, ffname)
9430 char_u *list;
9431 char_u *sfname;
9432 char_u *ffname;
9433 {
9434 char_u buf[100];
9435 char_u *tail;
9436 char_u *regpat;
9437 char allow_dirs;
9438 int match;
9439 char_u *p;
9440
9441 tail = gettail(sfname);
9442
9443 /* try all patterns in 'wildignore' */
9444 p = list;
9445 while (*p)
9446 {
9447 copy_option_part(&p, buf, 100, ",");
9448 regpat = file_pat_to_reg_pat(buf, NULL, &allow_dirs, FALSE);
9449 if (regpat == NULL)
9450 break;
9451 match = match_file_pat(regpat, NULL, ffname, sfname,
9452 tail, (int)allow_dirs);
9453 vim_free(regpat);
9454 if (match)
9455 return TRUE;
9456 }
9457 return FALSE;
9458 }
9459 #endif
9460
9461 /*
9462 * Convert the given pattern "pat" which has shell style wildcards in it, into
9463 * a regular expression, and return the result in allocated memory. If there
9464 * is a directory path separator to be matched, then TRUE is put in
9465 * allow_dirs, otherwise FALSE is put there -- webb.
9466 * Handle backslashes before special characters, like "\*" and "\ ".
9467 *
9468 * If FEAT_OSFILETYPE defined then pass initial <type> through unchanged. Eg:
9469 * '<html>myfile' becomes '<html>^myfile$' -- leonard.
9470 *
9471 * Returns NULL when out of memory.
9472 */
9473 /*ARGSUSED*/
9474 char_u *
9475 file_pat_to_reg_pat(pat, pat_end, allow_dirs, no_bslash)
9476 char_u *pat;
9477 char_u *pat_end; /* first char after pattern or NULL */
9478 char *allow_dirs; /* Result passed back out in here */
9479 int no_bslash; /* Don't use a backward slash as pathsep */
9480 {
9481 int size;
9482 char_u *endp;
9483 char_u *reg_pat;
9484 char_u *p;
9485 int i;
9486 int nested = 0;
9487 int add_dollar = TRUE;
9488 #ifdef FEAT_OSFILETYPE
9489 int check_length = 0;
9490 #endif
9491
9492 if (allow_dirs != NULL)
9493 *allow_dirs = FALSE;
9494 if (pat_end == NULL)
9495 pat_end = pat + STRLEN(pat);
9496
9497 #ifdef FEAT_OSFILETYPE
9498 /* Find out how much of the string is the filetype check */
9499 if (*pat == '<')
9500 {
9501 /* Count chars until the next '>' */
9502 for (p = pat + 1; p < pat_end && *p != '>'; p++)
9503 ;
9504 if (p < pat_end)
9505 {
9506 /* Pattern is of the form <.*>.* */
9507 check_length = p - pat + 1;
9508 if (p + 1 >= pat_end)
9509 {
9510 /* The 'pattern' is a filetype check ONLY */
9511 reg_pat = (char_u *)alloc(check_length + 1);
9512 if (reg_pat != NULL)
9513 {
9514 mch_memmove(reg_pat, pat, (size_t)check_length);
9515 reg_pat[check_length] = NUL;
9516 }
9517 return reg_pat;
9518 }
9519 }
9520 /* else: there was no closing '>' - assume it was a normal pattern */
9521
9522 }
9523 pat += check_length;
9524 size = 2 + check_length;
9525 #else
9526 size = 2; /* '^' at start, '$' at end */
9527 #endif
9528
9529 for (p = pat; p < pat_end; p++)
9530 {
9531 switch (*p)
9532 {
9533 case '*':
9534 case '.':
9535 case ',':
9536 case '{':
9537 case '}':
9538 case '~':
9539 size += 2; /* extra backslash */
9540 break;
9541 #ifdef BACKSLASH_IN_FILENAME
9542 case '\\':
9543 case '/':
9544 size += 4; /* could become "[\/]" */
9545 break;
9546 #endif
9547 default:
9548 size++;
9549 # ifdef FEAT_MBYTE
9550 if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
9551 {
9552 ++p;
9553 ++size;
9554 }
9555 # endif
9556 break;
9557 }
9558 }
9559 reg_pat = alloc(size + 1);
9560 if (reg_pat == NULL)
9561 return NULL;
9562
9563 #ifdef FEAT_OSFILETYPE
9564 /* Copy the type check in to the start. */
9565 if (check_length)
9566 mch_memmove(reg_pat, pat - check_length, (size_t)check_length);
9567 i = check_length;
9568 #else
9569 i = 0;
9570 #endif
9571
9572 if (pat[0] == '*')
9573 while (pat[0] == '*' && pat < pat_end - 1)
9574 pat++;
9575 else
9576 reg_pat[i++] = '^';
9577 endp = pat_end - 1;
9578 if (*endp == '*')
9579 {
9580 while (endp - pat > 0 && *endp == '*')
9581 endp--;
9582 add_dollar = FALSE;
9583 }
9584 for (p = pat; *p && nested >= 0 && p <= endp; p++)
9585 {
9586 switch (*p)
9587 {
9588 case '*':
9589 reg_pat[i++] = '.';
9590 reg_pat[i++] = '*';
9591 while (p[1] == '*') /* "**" matches like "*" */
9592 ++p;
9593 break;
9594 case '.':
9595 #ifdef RISCOS
9596 if (allow_dirs != NULL)
9597 *allow_dirs = TRUE;
9598 /* FALLTHROUGH */
9599 #endif
9600 case '~':
9601 reg_pat[i++] = '\\';
9602 reg_pat[i++] = *p;
9603 break;
9604 case '?':
9605 #ifdef RISCOS
9606 case '#':
9607 #endif
9608 reg_pat[i++] = '.';
9609 break;
9610 case '\\':
9611 if (p[1] == NUL)
9612 break;
9613 #ifdef BACKSLASH_IN_FILENAME
9614 if (!no_bslash)
9615 {
9616 /* translate:
9617 * "\x" to "\\x" e.g., "dir\file"
9618 * "\*" to "\\.*" e.g., "dir\*.c"
9619 * "\?" to "\\." e.g., "dir\??.c"
9620 * "\+" to "\+" e.g., "fileX\+.c"
9621 */
9622 if ((vim_isfilec(p[1]) || p[1] == '*' || p[1] == '?')
9623 && p[1] != '+')
9624 {
9625 reg_pat[i++] = '[';
9626 reg_pat[i++] = '\\';
9627 reg_pat[i++] = '/';
9628 reg_pat[i++] = ']';
9629 if (allow_dirs != NULL)
9630 *allow_dirs = TRUE;
9631 break;
9632 }
9633 }
9634 #endif
9635 if (*++p == '?'
9636 #ifdef BACKSLASH_IN_FILENAME
9637 && no_bslash
9638 #endif
9639 )
9640 reg_pat[i++] = '?';
9641 else
9642 if (*p == ',')
9643 reg_pat[i++] = ',';
9644 else
9645 {
9646 if (allow_dirs != NULL && vim_ispathsep(*p)
9647 #ifdef BACKSLASH_IN_FILENAME
9648 && (!no_bslash || *p != '\\')
9649 #endif
9650 )
9651 *allow_dirs = TRUE;
9652 reg_pat[i++] = '\\';
9653 reg_pat[i++] = *p;
9654 }
9655 break;
9656 #ifdef BACKSLASH_IN_FILENAME
9657 case '/':
9658 reg_pat[i++] = '[';
9659 reg_pat[i++] = '\\';
9660 reg_pat[i++] = '/';
9661 reg_pat[i++] = ']';
9662 if (allow_dirs != NULL)
9663 *allow_dirs = TRUE;
9664 break;
9665 #endif
9666 case '{':
9667 reg_pat[i++] = '\\';
9668 reg_pat[i++] = '(';
9669 nested++;
9670 break;
9671 case '}':
9672 reg_pat[i++] = '\\';
9673 reg_pat[i++] = ')';
9674 --nested;
9675 break;
9676 case ',':
9677 if (nested)
9678 {
9679 reg_pat[i++] = '\\';
9680 reg_pat[i++] = '|';
9681 }
9682 else
9683 reg_pat[i++] = ',';
9684 break;
9685 default:
9686 # ifdef FEAT_MBYTE
9687 if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
9688 reg_pat[i++] = *p++;
9689 else
9690 # endif
9691 if (allow_dirs != NULL && vim_ispathsep(*p))
9692 *allow_dirs = TRUE;
9693 reg_pat[i++] = *p;
9694 break;
9695 }
9696 }
9697 if (add_dollar)
9698 reg_pat[i++] = '$';
9699 reg_pat[i] = NUL;
9700 if (nested != 0)
9701 {
9702 if (nested < 0)
9703 EMSG(_("E219: Missing {."));
9704 else
9705 EMSG(_("E220: Missing }."));
9706 vim_free(reg_pat);
9707 reg_pat = NULL;
9708 }
9709 return reg_pat;
9710 }
Vim for the Mac