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