?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
add on-the-fly code checking
[vim_extended.git] / src / fileio.c
blob6f0bd8c31fffd6324a9ffd55a5f929124b243fbe
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 losing 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 losing 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 return retval;
4773 }
4774
4775 /*
4776 * Set the name of the current buffer. Use when the buffer doesn't have a
4777 * name and a ":r" or ":w" command with a file name is used.
4778 */
4779 static int
4780 set_rw_fname(fname, sfname)
4781 char_u *fname;
4782 char_u *sfname;
4783 {
4784 #ifdef FEAT_AUTOCMD
4785 /* It's like the unnamed buffer is deleted.... */
4786 if (curbuf->b_p_bl)
4787 apply_autocmds(EVENT_BUFDELETE, NULL, NULL, FALSE, curbuf);
4788 apply_autocmds(EVENT_BUFWIPEOUT, NULL, NULL, FALSE, curbuf);
4789 # ifdef FEAT_EVAL
4790 if (aborting()) /* autocmds may abort script processing */
4791 return FAIL;
4792 # endif
4793 #endif
4794
4795 if (setfname(curbuf, fname, sfname, FALSE) == OK)
4796 curbuf->b_flags |= BF_NOTEDITED;
4797
4798 #ifdef FEAT_AUTOCMD
4799 /* ....and a new named one is created */
4800 apply_autocmds(EVENT_BUFNEW, NULL, NULL, FALSE, curbuf);
4801 if (curbuf->b_p_bl)
4802 apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, curbuf);
4803 # ifdef FEAT_EVAL
4804 if (aborting()) /* autocmds may abort script processing */
4805 return FAIL;
4806 # endif
4807
4808 /* Do filetype detection now if 'filetype' is empty. */
4809 if (*curbuf->b_p_ft == NUL)
4810 {
4811 if (au_has_group((char_u *)"filetypedetect"))
4812 (void)do_doautocmd((char_u *)"filetypedetect BufRead", FALSE);
4813 do_modelines(0);
4814 }
4815 #endif
4816
4817 return OK;
4818 }
4819
4820 /*
4821 * Put file name into IObuff with quotes.
4822 */
4823 void
4824 msg_add_fname(buf, fname)
4825 buf_T *buf;
4826 char_u *fname;
4827 {
4828 if (fname == NULL)
4829 fname = (char_u *)"-stdin-";
4830 home_replace(buf, fname, IObuff + 1, IOSIZE - 4, TRUE);
4831 IObuff[0] = '"';
4832 STRCAT(IObuff, "\" ");
4833 }
4834
4835 /*
4836 * Append message for text mode to IObuff.
4837 * Return TRUE if something appended.
4838 */
4839 static int
4840 msg_add_fileformat(eol_type)
4841 int eol_type;
4842 {
4843 #ifndef USE_CRNL
4844 if (eol_type == EOL_DOS)
4845 {
4846 STRCAT(IObuff, shortmess(SHM_TEXT) ? _("[dos]") : _("[dos format]"));
4847 return TRUE;
4848 }
4849 #endif
4850 #ifndef USE_CR
4851 if (eol_type == EOL_MAC)
4852 {
4853 STRCAT(IObuff, shortmess(SHM_TEXT) ? _("[mac]") : _("[mac format]"));
4854 return TRUE;
4855 }
4856 #endif
4857 #if defined(USE_CRNL) || defined(USE_CR)
4858 if (eol_type == EOL_UNIX)
4859 {
4860 STRCAT(IObuff, shortmess(SHM_TEXT) ? _("[unix]") : _("[unix format]"));
4861 return TRUE;
4862 }
4863 #endif
4864 return FALSE;
4865 }
4866
4867 /*
4868 * Append line and character count to IObuff.
4869 */
4870 void
4871 msg_add_lines(insert_space, lnum, nchars)
4872 int insert_space;
4873 long lnum;
4874 long nchars;
4875 {
4876 char_u *p;
4877
4878 p = IObuff + STRLEN(IObuff);
4879
4880 if (insert_space)
4881 *p++ = ' ';
4882 if (shortmess(SHM_LINES))
4883 sprintf((char *)p, "%ldL, %ldC", lnum, nchars);
4884 else
4885 {
4886 if (lnum == 1)
4887 STRCPY(p, _("1 line, "));
4888 else
4889 sprintf((char *)p, _("%ld lines, "), lnum);
4890 p += STRLEN(p);
4891 if (nchars == 1)
4892 STRCPY(p, _("1 character"));
4893 else
4894 sprintf((char *)p, _("%ld characters"), nchars);
4895 }
4896 }
4897
4898 /*
4899 * Append message for missing line separator to IObuff.
4900 */
4901 static void
4902 msg_add_eol()
4903 {
4904 STRCAT(IObuff, shortmess(SHM_LAST) ? _("[noeol]") : _("[Incomplete last line]"));
4905 }
4906
4907 /*
4908 * Check modification time of file, before writing to it.
4909 * The size isn't checked, because using a tool like "gzip" takes care of
4910 * using the same timestamp but can't set the size.
4911 */
4912 static int
4913 check_mtime(buf, st)
4914 buf_T *buf;
4915 struct stat *st;
4916 {
4917 if (buf->b_mtime_read != 0
4918 && time_differs((long)st->st_mtime, buf->b_mtime_read))
4919 {
4920 msg_scroll = TRUE; /* don't overwrite messages here */
4921 msg_silent = 0; /* must give this prompt */
4922 /* don't use emsg() here, don't want to flush the buffers */
4923 MSG_ATTR(_("WARNING: The file has been changed since reading it!!!"),
4924 hl_attr(HLF_E));
4925 if (ask_yesno((char_u *)_("Do you really want to write to it"),
4926 TRUE) == 'n')
4927 return FAIL;
4928 msg_scroll = FALSE; /* always overwrite the file message now */
4929 }
4930 return OK;
4931 }
4932
4933 static int
4934 time_differs(t1, t2)
4935 long t1, t2;
4936 {
4937 #if defined(__linux__) || defined(MSDOS) || defined(MSWIN)
4938 /* On a FAT filesystem, esp. under Linux, there are only 5 bits to store
4939 * the seconds. Since the roundoff is done when flushing the inode, the
4940 * time may change unexpectedly by one second!!! */
4941 return (t1 - t2 > 1 || t2 - t1 > 1);
4942 #else
4943 return (t1 != t2);
4944 #endif
4945 }
4946
4947 /*
4948 * Call write() to write a number of bytes to the file.
4949 * Also handles encryption and 'encoding' conversion.
4950 *
4951 * Return FAIL for failure, OK otherwise.
4952 */
4953 static int
4954 buf_write_bytes(ip)
4955 struct bw_info *ip;
4956 {
4957 int wlen;
4958 char_u *buf = ip->bw_buf; /* data to write */
4959 int len = ip->bw_len; /* length of data */
4960 #ifdef HAS_BW_FLAGS
4961 int flags = ip->bw_flags; /* extra flags */
4962 #endif
4963
4964 #ifdef FEAT_MBYTE
4965 /*
4966 * Skip conversion when writing the crypt magic number or the BOM.
4967 */
4968 if (!(flags & FIO_NOCONVERT))
4969 {
4970 char_u *p;
4971 unsigned c;
4972 int n;
4973
4974 if (flags & FIO_UTF8)
4975 {
4976 /*
4977 * Convert latin1 in the buffer to UTF-8 in the file.
4978 */
4979 p = ip->bw_conv_buf; /* translate to buffer */
4980 for (wlen = 0; wlen < len; ++wlen)
4981 p += utf_char2bytes(buf[wlen], p);
4982 buf = ip->bw_conv_buf;
4983 len = (int)(p - ip->bw_conv_buf);
4984 }
4985 else if (flags & (FIO_UCS4 | FIO_UTF16 | FIO_UCS2 | FIO_LATIN1))
4986 {
4987 /*
4988 * Convert UTF-8 bytes in the buffer to UCS-2, UCS-4, UTF-16 or
4989 * Latin1 chars in the file.
4990 */
4991 if (flags & FIO_LATIN1)
4992 p = buf; /* translate in-place (can only get shorter) */
4993 else
4994 p = ip->bw_conv_buf; /* translate to buffer */
4995 for (wlen = 0; wlen < len; wlen += n)
4996 {
4997 if (wlen == 0 && ip->bw_restlen != 0)
4998 {
4999 int l;
5000
5001 /* Use remainder of previous call. Append the start of
5002 * buf[] to get a full sequence. Might still be too
5003 * short! */
5004 l = CONV_RESTLEN - ip->bw_restlen;
5005 if (l > len)
5006 l = len;
5007 mch_memmove(ip->bw_rest + ip->bw_restlen, buf, (size_t)l);
5008 n = utf_ptr2len_len(ip->bw_rest, ip->bw_restlen + l);
5009 if (n > ip->bw_restlen + len)
5010 {
5011 /* We have an incomplete byte sequence at the end to
5012 * be written. We can't convert it without the
5013 * remaining bytes. Keep them for the next call. */
5014 if (ip->bw_restlen + len > CONV_RESTLEN)
5015 return FAIL;
5016 ip->bw_restlen += len;
5017 break;
5018 }
5019 if (n > 1)
5020 c = utf_ptr2char(ip->bw_rest);
5021 else
5022 c = ip->bw_rest[0];
5023 if (n >= ip->bw_restlen)
5024 {
5025 n -= ip->bw_restlen;
5026 ip->bw_restlen = 0;
5027 }
5028 else
5029 {
5030 ip->bw_restlen -= n;
5031 mch_memmove(ip->bw_rest, ip->bw_rest + n,
5032 (size_t)ip->bw_restlen);
5033 n = 0;
5034 }
5035 }
5036 else
5037 {
5038 n = utf_ptr2len_len(buf + wlen, len - wlen);
5039 if (n > len - wlen)
5040 {
5041 /* We have an incomplete byte sequence at the end to
5042 * be written. We can't convert it without the
5043 * remaining bytes. Keep them for the next call. */
5044 if (len - wlen > CONV_RESTLEN)
5045 return FAIL;
5046 ip->bw_restlen = len - wlen;
5047 mch_memmove(ip->bw_rest, buf + wlen,
5048 (size_t)ip->bw_restlen);
5049 break;
5050 }
5051 if (n > 1)
5052 c = utf_ptr2char(buf + wlen);
5053 else
5054 c = buf[wlen];
5055 }
5056
5057 ip->bw_conv_error |= ucs2bytes(c, &p, flags);
5058 }
5059 if (flags & FIO_LATIN1)
5060 len = (int)(p - buf);
5061 else
5062 {
5063 buf = ip->bw_conv_buf;
5064 len = (int)(p - ip->bw_conv_buf);
5065 }
5066 }
5067
5068 # ifdef WIN3264
5069 else if (flags & FIO_CODEPAGE)
5070 {
5071 /*
5072 * Convert UTF-8 or codepage to UCS-2 and then to MS-Windows
5073 * codepage.
5074 */
5075 char_u *from;
5076 size_t fromlen;
5077 char_u *to;
5078 int u8c;
5079 BOOL bad = FALSE;
5080 int needed;
5081
5082 if (ip->bw_restlen > 0)
5083 {
5084 /* Need to concatenate the remainder of the previous call and
5085 * the bytes of the current call. Use the end of the
5086 * conversion buffer for this. */
5087 fromlen = len + ip->bw_restlen;
5088 from = ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
5089 mch_memmove(from, ip->bw_rest, (size_t)ip->bw_restlen);
5090 mch_memmove(from + ip->bw_restlen, buf, (size_t)len);
5091 }
5092 else
5093 {
5094 from = buf;
5095 fromlen = len;
5096 }
5097
5098 to = ip->bw_conv_buf;
5099 if (enc_utf8)
5100 {
5101 /* Convert from UTF-8 to UCS-2, to the start of the buffer.
5102 * The buffer has been allocated to be big enough. */
5103 while (fromlen > 0)
5104 {
5105 n = (int)utf_ptr2len_len(from, (int)fromlen);
5106 if (n > (int)fromlen) /* incomplete byte sequence */
5107 break;
5108 u8c = utf_ptr2char(from);
5109 *to++ = (u8c & 0xff);
5110 *to++ = (u8c >> 8);
5111 fromlen -= n;
5112 from += n;
5113 }
5114
5115 /* Copy remainder to ip->bw_rest[] to be used for the next
5116 * call. */
5117 if (fromlen > CONV_RESTLEN)
5118 {
5119 /* weird overlong sequence */
5120 ip->bw_conv_error = TRUE;
5121 return FAIL;
5122 }
5123 mch_memmove(ip->bw_rest, from, fromlen);
5124 ip->bw_restlen = (int)fromlen;
5125 }
5126 else
5127 {
5128 /* Convert from enc_codepage to UCS-2, to the start of the
5129 * buffer. The buffer has been allocated to be big enough. */
5130 ip->bw_restlen = 0;
5131 needed = MultiByteToWideChar(enc_codepage,
5132 MB_ERR_INVALID_CHARS, (LPCSTR)from, (int)fromlen,
5133 NULL, 0);
5134 if (needed == 0)
5135 {
5136 /* When conversion fails there may be a trailing byte. */
5137 needed = MultiByteToWideChar(enc_codepage,
5138 MB_ERR_INVALID_CHARS, (LPCSTR)from, (int)fromlen - 1,
5139 NULL, 0);
5140 if (needed == 0)
5141 {
5142 /* Conversion doesn't work. */
5143 ip->bw_conv_error = TRUE;
5144 return FAIL;
5145 }
5146 /* Save the trailing byte for the next call. */
5147 ip->bw_rest[0] = from[fromlen - 1];
5148 ip->bw_restlen = 1;
5149 }
5150 needed = MultiByteToWideChar(enc_codepage, MB_ERR_INVALID_CHARS,
5151 (LPCSTR)from, (int)(fromlen - ip->bw_restlen),
5152 (LPWSTR)to, needed);
5153 if (needed == 0)
5154 {
5155 /* Safety check: Conversion doesn't work. */
5156 ip->bw_conv_error = TRUE;
5157 return FAIL;
5158 }
5159 to += needed * 2;
5160 }
5161
5162 fromlen = to - ip->bw_conv_buf;
5163 buf = to;
5164 # ifdef CP_UTF8 /* VC 4.1 doesn't define CP_UTF8 */
5165 if (FIO_GET_CP(flags) == CP_UTF8)
5166 {
5167 /* Convert from UCS-2 to UTF-8, using the remainder of the
5168 * conversion buffer. Fails when out of space. */
5169 for (from = ip->bw_conv_buf; fromlen > 1; fromlen -= 2)
5170 {
5171 u8c = *from++;
5172 u8c += (*from++ << 8);
5173 to += utf_char2bytes(u8c, to);
5174 if (to + 6 >= ip->bw_conv_buf + ip->bw_conv_buflen)
5175 {
5176 ip->bw_conv_error = TRUE;
5177 return FAIL;
5178 }
5179 }
5180 len = (int)(to - buf);
5181 }
5182 else
5183 #endif
5184 {
5185 /* Convert from UCS-2 to the codepage, using the remainder of
5186 * the conversion buffer. If the conversion uses the default
5187 * character "0", the data doesn't fit in this encoding, so
5188 * fail. */
5189 len = WideCharToMultiByte(FIO_GET_CP(flags), 0,
5190 (LPCWSTR)ip->bw_conv_buf, (int)fromlen / sizeof(WCHAR),
5191 (LPSTR)to, (int)(ip->bw_conv_buflen - fromlen), 0,
5192 &bad);
5193 if (bad)
5194 {
5195 ip->bw_conv_error = TRUE;
5196 return FAIL;
5197 }
5198 }
5199 }
5200 # endif
5201
5202 # ifdef MACOS_CONVERT
5203 else if (flags & FIO_MACROMAN)
5204 {
5205 /*
5206 * Convert UTF-8 or latin1 to Apple MacRoman.
5207 */
5208 char_u *from;
5209 size_t fromlen;
5210
5211 if (ip->bw_restlen > 0)
5212 {
5213 /* Need to concatenate the remainder of the previous call and
5214 * the bytes of the current call. Use the end of the
5215 * conversion buffer for this. */
5216 fromlen = len + ip->bw_restlen;
5217 from = ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
5218 mch_memmove(from, ip->bw_rest, (size_t)ip->bw_restlen);
5219 mch_memmove(from + ip->bw_restlen, buf, (size_t)len);
5220 }
5221 else
5222 {
5223 from = buf;
5224 fromlen = len;
5225 }
5226
5227 if (enc2macroman(from, fromlen,
5228 ip->bw_conv_buf, &len, ip->bw_conv_buflen,
5229 ip->bw_rest, &ip->bw_restlen) == FAIL)
5230 {
5231 ip->bw_conv_error = TRUE;
5232 return FAIL;
5233 }
5234 buf = ip->bw_conv_buf;
5235 }
5236 # endif
5237
5238 # ifdef USE_ICONV
5239 if (ip->bw_iconv_fd != (iconv_t)-1)
5240 {
5241 const char *from;
5242 size_t fromlen;
5243 char *to;
5244 size_t tolen;
5245
5246 /* Convert with iconv(). */
5247 if (ip->bw_restlen > 0)
5248 {
5249 /* Need to concatenate the remainder of the previous call and
5250 * the bytes of the current call. Use the end of the
5251 * conversion buffer for this. */
5252 fromlen = len + ip->bw_restlen;
5253 from = (char *)ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
5254 mch_memmove((void *)from, ip->bw_rest, (size_t)ip->bw_restlen);
5255 mch_memmove((void *)(from + ip->bw_restlen), buf, (size_t)len);
5256 tolen = ip->bw_conv_buflen - fromlen;
5257 }
5258 else
5259 {
5260 from = (const char *)buf;
5261 fromlen = len;
5262 tolen = ip->bw_conv_buflen;
5263 }
5264 to = (char *)ip->bw_conv_buf;
5265
5266 if (ip->bw_first)
5267 {
5268 size_t save_len = tolen;
5269
5270 /* output the initial shift state sequence */
5271 (void)iconv(ip->bw_iconv_fd, NULL, NULL, &to, &tolen);
5272
5273 /* There is a bug in iconv() on Linux (which appears to be
5274 * wide-spread) which sets "to" to NULL and messes up "tolen".
5275 */
5276 if (to == NULL)
5277 {
5278 to = (char *)ip->bw_conv_buf;
5279 tolen = save_len;
5280 }
5281 ip->bw_first = FALSE;
5282 }
5283
5284 /*
5285 * If iconv() has an error or there is not enough room, fail.
5286 */
5287 if ((iconv(ip->bw_iconv_fd, (void *)&from, &fromlen, &to, &tolen)
5288 == (size_t)-1 && ICONV_ERRNO != ICONV_EINVAL)
5289 || fromlen > CONV_RESTLEN)
5290 {
5291 ip->bw_conv_error = TRUE;
5292 return FAIL;
5293 }
5294
5295 /* copy remainder to ip->bw_rest[] to be used for the next call. */
5296 if (fromlen > 0)
5297 mch_memmove(ip->bw_rest, (void *)from, fromlen);
5298 ip->bw_restlen = (int)fromlen;
5299
5300 buf = ip->bw_conv_buf;
5301 len = (int)((char_u *)to - ip->bw_conv_buf);
5302 }
5303 # endif
5304 }
5305 #endif /* FEAT_MBYTE */
5306
5307 #ifdef FEAT_CRYPT
5308 if (flags & FIO_ENCRYPTED) /* encrypt the data */
5309 {
5310 int ztemp, t, i;
5311
5312 for (i = 0; i < len; i++)
5313 {
5314 ztemp = buf[i];
5315 buf[i] = ZENCODE(ztemp, t);
5316 }
5317 }
5318 #endif
5319
5320 /* Repeat the write(), it may be interrupted by a signal. */
5321 while (len > 0)
5322 {
5323 wlen = vim_write(ip->bw_fd, buf, len);
5324 if (wlen <= 0) /* error! */
5325 return FAIL;
5326 len -= wlen;
5327 buf += wlen;
5328 }
5329 return OK;
5330 }
5331
5332 #ifdef FEAT_MBYTE
5333 /*
5334 * Convert a Unicode character to bytes.
5335 */
5336 static int
5337 ucs2bytes(c, pp, flags)
5338 unsigned c; /* in: character */
5339 char_u **pp; /* in/out: pointer to result */
5340 int flags; /* FIO_ flags */
5341 {
5342 char_u *p = *pp;
5343 int error = FALSE;
5344 int cc;
5345
5346
5347 if (flags & FIO_UCS4)
5348 {
5349 if (flags & FIO_ENDIAN_L)
5350 {
5351 *p++ = c;
5352 *p++ = (c >> 8);
5353 *p++ = (c >> 16);
5354 *p++ = (c >> 24);
5355 }
5356 else
5357 {
5358 *p++ = (c >> 24);
5359 *p++ = (c >> 16);
5360 *p++ = (c >> 8);
5361 *p++ = c;
5362 }
5363 }
5364 else if (flags & (FIO_UCS2 | FIO_UTF16))
5365 {
5366 if (c >= 0x10000)
5367 {
5368 if (flags & FIO_UTF16)
5369 {
5370 /* Make two words, ten bits of the character in each. First
5371 * word is 0xd800 - 0xdbff, second one 0xdc00 - 0xdfff */
5372 c -= 0x10000;
5373 if (c >= 0x100000)
5374 error = TRUE;
5375 cc = ((c >> 10) & 0x3ff) + 0xd800;
5376 if (flags & FIO_ENDIAN_L)
5377 {
5378 *p++ = cc;
5379 *p++ = ((unsigned)cc >> 8);
5380 }
5381 else
5382 {
5383 *p++ = ((unsigned)cc >> 8);
5384 *p++ = cc;
5385 }
5386 c = (c & 0x3ff) + 0xdc00;
5387 }
5388 else
5389 error = TRUE;
5390 }
5391 if (flags & FIO_ENDIAN_L)
5392 {
5393 *p++ = c;
5394 *p++ = (c >> 8);
5395 }
5396 else
5397 {
5398 *p++ = (c >> 8);
5399 *p++ = c;
5400 }
5401 }
5402 else /* Latin1 */
5403 {
5404 if (c >= 0x100)
5405 {
5406 error = TRUE;
5407 *p++ = 0xBF;
5408 }
5409 else
5410 *p++ = c;
5411 }
5412
5413 *pp = p;
5414 return error;
5415 }
5416
5417 /*
5418 * Return TRUE if "a" and "b" are the same 'encoding'.
5419 * Ignores difference between "ansi" and "latin1", "ucs-4" and "ucs-4be", etc.
5420 */
5421 static int
5422 same_encoding(a, b)
5423 char_u *a;
5424 char_u *b;
5425 {
5426 int f;
5427
5428 if (STRCMP(a, b) == 0)
5429 return TRUE;
5430 f = get_fio_flags(a);
5431 return (f != 0 && get_fio_flags(b) == f);
5432 }
5433
5434 /*
5435 * Check "ptr" for a unicode encoding and return the FIO_ flags needed for the
5436 * internal conversion.
5437 * if "ptr" is an empty string, use 'encoding'.
5438 */
5439 static int
5440 get_fio_flags(ptr)
5441 char_u *ptr;
5442 {
5443 int prop;
5444
5445 if (*ptr == NUL)
5446 ptr = p_enc;
5447
5448 prop = enc_canon_props(ptr);
5449 if (prop & ENC_UNICODE)
5450 {
5451 if (prop & ENC_2BYTE)
5452 {
5453 if (prop & ENC_ENDIAN_L)
5454 return FIO_UCS2 | FIO_ENDIAN_L;
5455 return FIO_UCS2;
5456 }
5457 if (prop & ENC_4BYTE)
5458 {
5459 if (prop & ENC_ENDIAN_L)
5460 return FIO_UCS4 | FIO_ENDIAN_L;
5461 return FIO_UCS4;
5462 }
5463 if (prop & ENC_2WORD)
5464 {
5465 if (prop & ENC_ENDIAN_L)
5466 return FIO_UTF16 | FIO_ENDIAN_L;
5467 return FIO_UTF16;
5468 }
5469 return FIO_UTF8;
5470 }
5471 if (prop & ENC_LATIN1)
5472 return FIO_LATIN1;
5473 /* must be ENC_DBCS, requires iconv() */
5474 return 0;
5475 }
5476
5477 #ifdef WIN3264
5478 /*
5479 * Check "ptr" for a MS-Windows codepage name and return the FIO_ flags needed
5480 * for the conversion MS-Windows can do for us. Also accept "utf-8".
5481 * Used for conversion between 'encoding' and 'fileencoding'.
5482 */
5483 static int
5484 get_win_fio_flags(ptr)
5485 char_u *ptr;
5486 {
5487 int cp;
5488
5489 /* Cannot do this when 'encoding' is not utf-8 and not a codepage. */
5490 if (!enc_utf8 && enc_codepage <= 0)
5491 return 0;
5492
5493 cp = encname2codepage(ptr);
5494 if (cp == 0)
5495 {
5496 # ifdef CP_UTF8 /* VC 4.1 doesn't define CP_UTF8 */
5497 if (STRCMP(ptr, "utf-8") == 0)
5498 cp = CP_UTF8;
5499 else
5500 # endif
5501 return 0;
5502 }
5503 return FIO_PUT_CP(cp) | FIO_CODEPAGE;
5504 }
5505 #endif
5506
5507 #ifdef MACOS_X
5508 /*
5509 * Check "ptr" for a Carbon supported encoding and return the FIO_ flags
5510 * needed for the internal conversion to/from utf-8 or latin1.
5511 */
5512 static int
5513 get_mac_fio_flags(ptr)
5514 char_u *ptr;
5515 {
5516 if ((enc_utf8 || STRCMP(p_enc, "latin1") == 0)
5517 && (enc_canon_props(ptr) & ENC_MACROMAN))
5518 return FIO_MACROMAN;
5519 return 0;
5520 }
5521 #endif
5522
5523 /*
5524 * Check for a Unicode BOM (Byte Order Mark) at the start of p[size].
5525 * "size" must be at least 2.
5526 * Return the name of the encoding and set "*lenp" to the length.
5527 * Returns NULL when no BOM found.
5528 */
5529 static char_u *
5530 check_for_bom(p, size, lenp, flags)
5531 char_u *p;
5532 long size;
5533 int *lenp;
5534 int flags;
5535 {
5536 char *name = NULL;
5537 int len = 2;
5538
5539 if (p[0] == 0xef && p[1] == 0xbb && size >= 3 && p[2] == 0xbf
5540 && (flags == FIO_ALL || flags == FIO_UTF8 || flags == 0))
5541 {
5542 name = "utf-8"; /* EF BB BF */
5543 len = 3;
5544 }
5545 else if (p[0] == 0xff && p[1] == 0xfe)
5546 {
5547 if (size >= 4 && p[2] == 0 && p[3] == 0
5548 && (flags == FIO_ALL || flags == (FIO_UCS4 | FIO_ENDIAN_L)))
5549 {
5550 name = "ucs-4le"; /* FF FE 00 00 */
5551 len = 4;
5552 }
5553 else if (flags == FIO_ALL || flags == (FIO_UCS2 | FIO_ENDIAN_L))
5554 name = "ucs-2le"; /* FF FE */
5555 else if (flags == (FIO_UTF16 | FIO_ENDIAN_L))
5556 name = "utf-16le"; /* FF FE */
5557 }
5558 else if (p[0] == 0xfe && p[1] == 0xff
5559 && (flags == FIO_ALL || flags == FIO_UCS2 || flags == FIO_UTF16))
5560 {
5561 /* Default to utf-16, it works also for ucs-2 text. */
5562 if (flags == FIO_UCS2)
5563 name = "ucs-2"; /* FE FF */
5564 else
5565 name = "utf-16"; /* FE FF */
5566 }
5567 else if (size >= 4 && p[0] == 0 && p[1] == 0 && p[2] == 0xfe
5568 && p[3] == 0xff && (flags == FIO_ALL || flags == FIO_UCS4))
5569 {
5570 name = "ucs-4"; /* 00 00 FE FF */
5571 len = 4;
5572 }
5573
5574 *lenp = len;
5575 return (char_u *)name;
5576 }
5577
5578 /*
5579 * Generate a BOM in "buf[4]" for encoding "name".
5580 * Return the length of the BOM (zero when no BOM).
5581 */
5582 static int
5583 make_bom(buf, name)
5584 char_u *buf;
5585 char_u *name;
5586 {
5587 int flags;
5588 char_u *p;
5589
5590 flags = get_fio_flags(name);
5591
5592 /* Can't put a BOM in a non-Unicode file. */
5593 if (flags == FIO_LATIN1 || flags == 0)
5594 return 0;
5595
5596 if (flags == FIO_UTF8) /* UTF-8 */
5597 {
5598 buf[0] = 0xef;
5599 buf[1] = 0xbb;
5600 buf[2] = 0xbf;
5601 return 3;
5602 }
5603 p = buf;
5604 (void)ucs2bytes(0xfeff, &p, flags);
5605 return (int)(p - buf);
5606 }
5607 #endif
5608
5609 #if defined(FEAT_VIMINFO) || defined(FEAT_BROWSE) || \
5610 defined(FEAT_QUICKFIX) || defined(FEAT_AUTOCMD) || defined(PROTO)
5611 /*
5612 * Try to find a shortname by comparing the fullname with the current
5613 * directory.
5614 * Returns "full_path" or pointer into "full_path" if shortened.
5615 */
5616 char_u *
5617 shorten_fname1(full_path)
5618 char_u *full_path;
5619 {
5620 char_u dirname[MAXPATHL];
5621 char_u *p = full_path;
5622
5623 if (mch_dirname(dirname, MAXPATHL) == OK)
5624 {
5625 p = shorten_fname(full_path, dirname);
5626 if (p == NULL || *p == NUL)
5627 p = full_path;
5628 }
5629 return p;
5630 }
5631 #endif
5632
5633 /*
5634 * Try to find a shortname by comparing the fullname with the current
5635 * directory.
5636 * Returns NULL if not shorter name possible, pointer into "full_path"
5637 * otherwise.
5638 */
5639 char_u *
5640 shorten_fname(full_path, dir_name)
5641 char_u *full_path;
5642 char_u *dir_name;
5643 {
5644 int len;
5645 char_u *p;
5646
5647 if (full_path == NULL)
5648 return NULL;
5649 len = (int)STRLEN(dir_name);
5650 if (fnamencmp(dir_name, full_path, len) == 0)
5651 {
5652 p = full_path + len;
5653 #if defined(MSDOS) || defined(MSWIN) || defined(OS2)
5654 /*
5655 * MSDOS: when a file is in the root directory, dir_name will end in a
5656 * slash, since C: by itself does not define a specific dir. In this
5657 * case p may already be correct. <negri>
5658 */
5659 if (!((len > 2) && (*(p - 2) == ':')))
5660 #endif
5661 {
5662 if (vim_ispathsep(*p))
5663 ++p;
5664 #ifndef VMS /* the path separator is always part of the path */
5665 else
5666 p = NULL;
5667 #endif
5668 }
5669 }
5670 #if defined(MSDOS) || defined(MSWIN) || defined(OS2)
5671 /*
5672 * When using a file in the current drive, remove the drive name:
5673 * "A:\dir\file" -> "\dir\file". This helps when moving a session file on
5674 * a floppy from "A:\dir" to "B:\dir".
5675 */
5676 else if (len > 3
5677 && TOUPPER_LOC(full_path[0]) == TOUPPER_LOC(dir_name[0])
5678 && full_path[1] == ':'
5679 && vim_ispathsep(full_path[2]))
5680 p = full_path + 2;
5681 #endif
5682 else
5683 p = NULL;
5684 return p;
5685 }
5686
5687 /*
5688 * Shorten filenames for all buffers.
5689 * When "force" is TRUE: Use full path from now on for files currently being
5690 * edited, both for file name and swap file name. Try to shorten the file
5691 * names a bit, if safe to do so.
5692 * When "force" is FALSE: Only try to shorten absolute file names.
5693 * For buffers that have buftype "nofile" or "scratch": never change the file
5694 * name.
5695 */
5696 void
5697 shorten_fnames(force)
5698 int force;
5699 {
5700 char_u dirname[MAXPATHL];
5701 buf_T *buf;
5702 char_u *p;
5703
5704 mch_dirname(dirname, MAXPATHL);
5705 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
5706 {
5707 if (buf->b_fname != NULL
5708 #ifdef FEAT_QUICKFIX
5709 && !bt_nofile(buf)
5710 #endif
5711 && !path_with_url(buf->b_fname)
5712 && (force
5713 || buf->b_sfname == NULL
5714 || mch_isFullName(buf->b_sfname)))
5715 {
5716 vim_free(buf->b_sfname);
5717 buf->b_sfname = NULL;
5718 p = shorten_fname(buf->b_ffname, dirname);
5719 if (p != NULL)
5720 {
5721 buf->b_sfname = vim_strsave(p);
5722 buf->b_fname = buf->b_sfname;
5723 }
5724 if (p == NULL || buf->b_fname == NULL)
5725 buf->b_fname = buf->b_ffname;
5726 }
5727
5728 /* Always make the swap file name a full path, a "nofile" buffer may
5729 * also have a swap file. */
5730 mf_fullname(buf->b_ml.ml_mfp);
5731 }
5732 #ifdef FEAT_WINDOWS
5733 status_redraw_all();
5734 redraw_tabline = TRUE;
5735 #endif
5736 }
5737
5738 #if (defined(FEAT_DND) && defined(FEAT_GUI_GTK)) \
5739 || defined(FEAT_GUI_MSWIN) \
5740 || defined(FEAT_GUI_MAC) \
5741 || defined(PROTO)
5742 /*
5743 * Shorten all filenames in "fnames[count]" by current directory.
5744 */
5745 void
5746 shorten_filenames(fnames, count)
5747 char_u **fnames;
5748 int count;
5749 {
5750 int i;
5751 char_u dirname[MAXPATHL];
5752 char_u *p;
5753
5754 if (fnames == NULL || count < 1)
5755 return;
5756 mch_dirname(dirname, sizeof(dirname));
5757 for (i = 0; i < count; ++i)
5758 {
5759 if ((p = shorten_fname(fnames[i], dirname)) != NULL)
5760 {
5761 /* shorten_fname() returns pointer in given "fnames[i]". If free
5762 * "fnames[i]" first, "p" becomes invalid. So we need to copy
5763 * "p" first then free fnames[i]. */
5764 p = vim_strsave(p);
5765 vim_free(fnames[i]);
5766 fnames[i] = p;
5767 }
5768 }
5769 }
5770 #endif
5771
5772 /*
5773 * add extension to file name - change path/fo.o.h to path/fo.o.h.ext or
5774 * fo_o_h.ext for MSDOS or when shortname option set.
5775 *
5776 * Assumed that fname is a valid name found in the filesystem we assure that
5777 * the return value is a different name and ends in 'ext'.
5778 * "ext" MUST be at most 4 characters long if it starts with a dot, 3
5779 * characters otherwise.
5780 * Space for the returned name is allocated, must be freed later.
5781 * Returns NULL when out of memory.
5782 */
5783 char_u *
5784 modname(fname, ext, prepend_dot)
5785 char_u *fname, *ext;
5786 int prepend_dot; /* may prepend a '.' to file name */
5787 {
5788 return buf_modname(
5789 #ifdef SHORT_FNAME
5790 TRUE,
5791 #else
5792 (curbuf->b_p_sn || curbuf->b_shortname),
5793 #endif
5794 fname, ext, prepend_dot);
5795 }
5796
5797 char_u *
5798 buf_modname(shortname, fname, ext, prepend_dot)
5799 int shortname; /* use 8.3 file name */
5800 char_u *fname, *ext;
5801 int prepend_dot; /* may prepend a '.' to file name */
5802 {
5803 char_u *retval;
5804 char_u *s;
5805 char_u *e;
5806 char_u *ptr;
5807 int fnamelen, extlen;
5808
5809 extlen = (int)STRLEN(ext);
5810
5811 /*
5812 * If there is no file name we must get the name of the current directory
5813 * (we need the full path in case :cd is used).
5814 */
5815 if (fname == NULL || *fname == NUL)
5816 {
5817 retval = alloc((unsigned)(MAXPATHL + extlen + 3));
5818 if (retval == NULL)
5819 return NULL;
5820 if (mch_dirname(retval, MAXPATHL) == FAIL ||
5821 (fnamelen = (int)STRLEN(retval)) == 0)
5822 {
5823 vim_free(retval);
5824 return NULL;
5825 }
5826 if (!after_pathsep(retval, retval + fnamelen))
5827 {
5828 retval[fnamelen++] = PATHSEP;
5829 retval[fnamelen] = NUL;
5830 }
5831 #ifndef SHORT_FNAME
5832 prepend_dot = FALSE; /* nothing to prepend a dot to */
5833 #endif
5834 }
5835 else
5836 {
5837 fnamelen = (int)STRLEN(fname);
5838 retval = alloc((unsigned)(fnamelen + extlen + 3));
5839 if (retval == NULL)
5840 return NULL;
5841 STRCPY(retval, fname);
5842 #ifdef VMS
5843 vms_remove_version(retval); /* we do not need versions here */
5844 #endif
5845 }
5846
5847 /*
5848 * search backwards until we hit a '/', '\' or ':' replacing all '.'
5849 * by '_' for MSDOS or when shortname option set and ext starts with a dot.
5850 * Then truncate what is after the '/', '\' or ':' to 8 characters for
5851 * MSDOS and 26 characters for AMIGA, a lot more for UNIX.
5852 */
5853 for (ptr = retval + fnamelen; ptr > retval; mb_ptr_back(retval, ptr))
5854 {
5855 #ifndef RISCOS
5856 if (*ext == '.'
5857 # ifdef USE_LONG_FNAME
5858 && (!USE_LONG_FNAME || shortname)
5859 # else
5860 # ifndef SHORT_FNAME
5861 && shortname
5862 # endif
5863 # endif
5864 )
5865 if (*ptr == '.') /* replace '.' by '_' */
5866 *ptr = '_';
5867 #endif
5868 if (vim_ispathsep(*ptr))
5869 {
5870 ++ptr;
5871 break;
5872 }
5873 }
5874
5875 /* the file name has at most BASENAMELEN characters. */
5876 #ifndef SHORT_FNAME
5877 if (STRLEN(ptr) > (unsigned)BASENAMELEN)
5878 ptr[BASENAMELEN] = '\0';
5879 #endif
5880
5881 s = ptr + STRLEN(ptr);
5882
5883 /*
5884 * For 8.3 file names we may have to reduce the length.
5885 */
5886 #ifdef USE_LONG_FNAME
5887 if (!USE_LONG_FNAME || shortname)
5888 #else
5889 # ifndef SHORT_FNAME
5890 if (shortname)
5891 # endif
5892 #endif
5893 {
5894 /*
5895 * If there is no file name, or the file name ends in '/', and the
5896 * extension starts with '.', put a '_' before the dot, because just
5897 * ".ext" is invalid.
5898 */
5899 if (fname == NULL || *fname == NUL
5900 || vim_ispathsep(fname[STRLEN(fname) - 1]))
5901 {
5902 #ifdef RISCOS
5903 if (*ext == '/')
5904 #else
5905 if (*ext == '.')
5906 #endif
5907 *s++ = '_';
5908 }
5909 /*
5910 * If the extension starts with '.', truncate the base name at 8
5911 * characters
5912 */
5913 #ifdef RISCOS
5914 /* We normally use '/', but swap files are '_' */
5915 else if (*ext == '/' || *ext == '_')
5916 #else
5917 else if (*ext == '.')
5918 #endif
5919 {
5920 if (s - ptr > (size_t)8)
5921 {
5922 s = ptr + 8;
5923 *s = '\0';
5924 }
5925 }
5926 /*
5927 * If the extension doesn't start with '.', and the file name
5928 * doesn't have an extension yet, append a '.'
5929 */
5930 #ifdef RISCOS
5931 else if ((e = vim_strchr(ptr, '/')) == NULL)
5932 *s++ = '/';
5933 #else
5934 else if ((e = vim_strchr(ptr, '.')) == NULL)
5935 *s++ = '.';
5936 #endif
5937 /*
5938 * If the extension doesn't start with '.', and there already is an
5939 * extension, it may need to be truncated
5940 */
5941 else if ((int)STRLEN(e) + extlen > 4)
5942 s = e + 4 - extlen;
5943 }
5944 #if defined(OS2) || defined(USE_LONG_FNAME) || defined(WIN3264)
5945 /*
5946 * If there is no file name, and the extension starts with '.', put a
5947 * '_' before the dot, because just ".ext" may be invalid if it's on a
5948 * FAT partition, and on HPFS it doesn't matter.
5949 */
5950 else if ((fname == NULL || *fname == NUL) && *ext == '.')
5951 *s++ = '_';
5952 #endif
5953
5954 /*
5955 * Append the extension.
5956 * ext can start with '.' and cannot exceed 3 more characters.
5957 */
5958 STRCPY(s, ext);
5959
5960 #ifndef SHORT_FNAME
5961 /*
5962 * Prepend the dot.
5963 */
5964 if (prepend_dot && !shortname && *(e = gettail(retval)) !=
5965 #ifdef RISCOS
5966 '/'
5967 #else
5968 '.'
5969 #endif
5970 #ifdef USE_LONG_FNAME
5971 && USE_LONG_FNAME
5972 #endif
5973 )
5974 {
5975 STRMOVE(e + 1, e);
5976 #ifdef RISCOS
5977 *e = '/';
5978 #else
5979 *e = '.';
5980 #endif
5981 }
5982 #endif
5983
5984 /*
5985 * Check that, after appending the extension, the file name is really
5986 * different.
5987 */
5988 if (fname != NULL && STRCMP(fname, retval) == 0)
5989 {
5990 /* we search for a character that can be replaced by '_' */
5991 while (--s >= ptr)
5992 {
5993 if (*s != '_')
5994 {
5995 *s = '_';
5996 break;
5997 }
5998 }
5999 if (s < ptr) /* fname was "________.<ext>", how tricky! */
6000 *ptr = 'v';
6001 }
6002 return retval;
6003 }
6004
6005 /*
6006 * Like fgets(), but if the file line is too long, it is truncated and the
6007 * rest of the line is thrown away. Returns TRUE for end-of-file.
6008 */
6009 int
6010 vim_fgets(buf, size, fp)
6011 char_u *buf;
6012 int size;
6013 FILE *fp;
6014 {
6015 char *eof;
6016 #define FGETS_SIZE 200
6017 char tbuf[FGETS_SIZE];
6018
6019 buf[size - 2] = NUL;
6020 #ifdef USE_CR
6021 eof = fgets_cr((char *)buf, size, fp);
6022 #else
6023 eof = fgets((char *)buf, size, fp);
6024 #endif
6025 if (buf[size - 2] != NUL && buf[size - 2] != '\n')
6026 {
6027 buf[size - 1] = NUL; /* Truncate the line */
6028
6029 /* Now throw away the rest of the line: */
6030 do
6031 {
6032 tbuf[FGETS_SIZE - 2] = NUL;
6033 #ifdef USE_CR
6034 fgets_cr((char *)tbuf, FGETS_SIZE, fp);
6035 #else
6036 fgets((char *)tbuf, FGETS_SIZE, fp);
6037 #endif
6038 } while (tbuf[FGETS_SIZE - 2] != NUL && tbuf[FGETS_SIZE - 2] != '\n');
6039 }
6040 return (eof == NULL);
6041 }
6042
6043 #if defined(USE_CR) || defined(PROTO)
6044 /*
6045 * Like vim_fgets(), but accept any line terminator: CR, CR-LF or LF.
6046 * Returns TRUE for end-of-file.
6047 * Only used for the Mac, because it's much slower than vim_fgets().
6048 */
6049 int
6050 tag_fgets(buf, size, fp)
6051 char_u *buf;
6052 int size;
6053 FILE *fp;
6054 {
6055 int i = 0;
6056 int c;
6057 int eof = FALSE;
6058
6059 for (;;)
6060 {
6061 c = fgetc(fp);
6062 if (c == EOF)
6063 {
6064 eof = TRUE;
6065 break;
6066 }
6067 if (c == '\r')
6068 {
6069 /* Always store a NL for end-of-line. */
6070 if (i < size - 1)
6071 buf[i++] = '\n';
6072 c = fgetc(fp);
6073 if (c != '\n') /* Macintosh format: single CR. */
6074 ungetc(c, fp);
6075 break;
6076 }
6077 if (i < size - 1)
6078 buf[i++] = c;
6079 if (c == '\n')
6080 break;
6081 }
6082 buf[i] = NUL;
6083 return eof;
6084 }
6085 #endif
6086
6087 /*
6088 * rename() only works if both files are on the same file system, this
6089 * function will (attempts to?) copy the file across if rename fails -- webb
6090 * Return -1 for failure, 0 for success.
6091 */
6092 int
6093 vim_rename(from, to)
6094 char_u *from;
6095 char_u *to;
6096 {
6097 int fd_in;
6098 int fd_out;
6099 int n;
6100 char *errmsg = NULL;
6101 char *buffer;
6102 #ifdef AMIGA
6103 BPTR flock;
6104 #endif
6105 struct stat st;
6106 long perm;
6107 #ifdef HAVE_ACL
6108 vim_acl_T acl; /* ACL from original file */
6109 #endif
6110
6111 /*
6112 * When the names are identical, there is nothing to do.
6113 */
6114 if (fnamecmp(from, to) == 0)
6115 return 0;
6116
6117 /*
6118 * Fail if the "from" file doesn't exist. Avoids that "to" is deleted.
6119 */
6120 if (mch_stat((char *)from, &st) < 0)
6121 return -1;
6122
6123 /*
6124 * Delete the "to" file, this is required on some systems to make the
6125 * mch_rename() work, on other systems it makes sure that we don't have
6126 * two files when the mch_rename() fails.
6127 */
6128
6129 #ifdef AMIGA
6130 /*
6131 * With MSDOS-compatible filesystems (crossdos, messydos) it is possible
6132 * that the name of the "to" file is the same as the "from" file, even
6133 * though the names are different. To avoid the chance of accidentally
6134 * deleting the "from" file (horror!) we lock it during the remove.
6135 *
6136 * When used for making a backup before writing the file: This should not
6137 * happen with ":w", because startscript() should detect this problem and
6138 * set buf->b_shortname, causing modname() to return a correct ".bak" file
6139 * name. This problem does exist with ":w filename", but then the
6140 * original file will be somewhere else so the backup isn't really
6141 * important. If autoscripting is off the rename may fail.
6142 */
6143 flock = Lock((UBYTE *)from, (long)ACCESS_READ);
6144 #endif
6145 mch_remove(to);
6146 #ifdef AMIGA
6147 if (flock)
6148 UnLock(flock);
6149 #endif
6150
6151 /*
6152 * First try a normal rename, return if it works.
6153 */
6154 if (mch_rename((char *)from, (char *)to) == 0)
6155 return 0;
6156
6157 /*
6158 * Rename() failed, try copying the file.
6159 */
6160 perm = mch_getperm(from);
6161 #ifdef HAVE_ACL
6162 /* For systems that support ACL: get the ACL from the original file. */
6163 acl = mch_get_acl(from);
6164 #endif
6165 fd_in = mch_open((char *)from, O_RDONLY|O_EXTRA, 0);
6166 if (fd_in == -1)
6167 {
6168 #ifdef HAVE_ACL
6169 mch_free_acl(acl);
6170 #endif
6171 return -1;
6172 }
6173
6174 /* Create the new file with same permissions as the original. */
6175 fd_out = mch_open((char *)to,
6176 O_CREAT|O_EXCL|O_WRONLY|O_EXTRA|O_NOFOLLOW, (int)perm);
6177 if (fd_out == -1)
6178 {
6179 close(fd_in);
6180 #ifdef HAVE_ACL
6181 mch_free_acl(acl);
6182 #endif
6183 return -1;
6184 }
6185
6186 buffer = (char *)alloc(BUFSIZE);
6187 if (buffer == NULL)
6188 {
6189 close(fd_out);
6190 close(fd_in);
6191 #ifdef HAVE_ACL
6192 mch_free_acl(acl);
6193 #endif
6194 return -1;
6195 }
6196
6197 while ((n = vim_read(fd_in, buffer, BUFSIZE)) > 0)
6198 if (vim_write(fd_out, buffer, n) != n)
6199 {
6200 errmsg = _("E208: Error writing to \"%s\"");
6201 break;
6202 }
6203
6204 vim_free(buffer);
6205 close(fd_in);
6206 if (close(fd_out) < 0)
6207 errmsg = _("E209: Error closing \"%s\"");
6208 if (n < 0)
6209 {
6210 errmsg = _("E210: Error reading \"%s\"");
6211 to = from;
6212 }
6213 #ifndef UNIX /* for Unix mch_open() already set the permission */
6214 mch_setperm(to, perm);
6215 #endif
6216 #ifdef HAVE_ACL
6217 mch_set_acl(to, acl);
6218 mch_free_acl(acl);
6219 #endif
6220 if (errmsg != NULL)
6221 {
6222 EMSG2(errmsg, to);
6223 return -1;
6224 }
6225 mch_remove(from);
6226 return 0;
6227 }
6228
6229 static int already_warned = FALSE;
6230
6231 /*
6232 * Check if any not hidden buffer has been changed.
6233 * Postpone the check if there are characters in the stuff buffer, a global
6234 * command is being executed, a mapping is being executed or an autocommand is
6235 * busy.
6236 * Returns TRUE if some message was written (screen should be redrawn and
6237 * cursor positioned).
6238 */
6239 int
6240 check_timestamps(focus)
6241 int focus; /* called for GUI focus event */
6242 {
6243 buf_T *buf;
6244 int didit = 0;
6245 int n;
6246
6247 /* Don't check timestamps while system() or another low-level function may
6248 * cause us to lose and gain focus. */
6249 if (no_check_timestamps > 0)
6250 return FALSE;
6251
6252 /* Avoid doing a check twice. The OK/Reload dialog can cause a focus
6253 * event and we would keep on checking if the file is steadily growing.
6254 * Do check again after typing something. */
6255 if (focus && did_check_timestamps)
6256 {
6257 need_check_timestamps = TRUE;
6258 return FALSE;
6259 }
6260
6261 if (!stuff_empty() || global_busy || !typebuf_typed()
6262 #ifdef FEAT_AUTOCMD
6263 || autocmd_busy || curbuf_lock > 0
6264 #endif
6265 )
6266 need_check_timestamps = TRUE; /* check later */
6267 else
6268 {
6269 ++no_wait_return;
6270 did_check_timestamps = TRUE;
6271 already_warned = FALSE;
6272 for (buf = firstbuf; buf != NULL; )
6273 {
6274 /* Only check buffers in a window. */
6275 if (buf->b_nwindows > 0)
6276 {
6277 n = buf_check_timestamp(buf, focus);
6278 if (didit < n)
6279 didit = n;
6280 if (n > 0 && !buf_valid(buf))
6281 {
6282 /* Autocommands have removed the buffer, start at the
6283 * first one again. */
6284 buf = firstbuf;
6285 continue;
6286 }
6287 }
6288 buf = buf->b_next;
6289 }
6290 --no_wait_return;
6291 need_check_timestamps = FALSE;
6292 if (need_wait_return && didit == 2)
6293 {
6294 /* make sure msg isn't overwritten */
6295 msg_puts((char_u *)"\n");
6296 out_flush();
6297 }
6298 }
6299 return didit;
6300 }
6301
6302 /*
6303 * Move all the lines from buffer "frombuf" to buffer "tobuf".
6304 * Return OK or FAIL. When FAIL "tobuf" is incomplete and/or "frombuf" is not
6305 * empty.
6306 */
6307 static int
6308 move_lines(frombuf, tobuf)
6309 buf_T *frombuf;
6310 buf_T *tobuf;
6311 {
6312 buf_T *tbuf = curbuf;
6313 int retval = OK;
6314 linenr_T lnum;
6315 char_u *p;
6316
6317 /* Copy the lines in "frombuf" to "tobuf". */
6318 curbuf = tobuf;
6319 for (lnum = 1; lnum <= frombuf->b_ml.ml_line_count; ++lnum)
6320 {
6321 p = vim_strsave(ml_get_buf(frombuf, lnum, FALSE));
6322 if (p == NULL || ml_append(lnum - 1, p, 0, FALSE) == FAIL)
6323 {
6324 vim_free(p);
6325 retval = FAIL;
6326 break;
6327 }
6328 vim_free(p);
6329 }
6330
6331 /* Delete all the lines in "frombuf". */
6332 if (retval != FAIL)
6333 {
6334 curbuf = frombuf;
6335 for (lnum = curbuf->b_ml.ml_line_count; lnum > 0; --lnum)
6336 if (ml_delete(lnum, FALSE) == FAIL)
6337 {
6338 /* Oops! We could try putting back the saved lines, but that
6339 * might fail again... */
6340 retval = FAIL;
6341 break;
6342 }
6343 }
6344
6345 curbuf = tbuf;
6346 return retval;
6347 }
6348
6349 /*
6350 * Check if buffer "buf" has been changed.
6351 * Also check if the file for a new buffer unexpectedly appeared.
6352 * return 1 if a changed buffer was found.
6353 * return 2 if a message has been displayed.
6354 * return 0 otherwise.
6355 */
6356 /*ARGSUSED*/
6357 int
6358 buf_check_timestamp(buf, focus)
6359 buf_T *buf;
6360 int focus; /* called for GUI focus event */
6361 {
6362 struct stat st;
6363 int stat_res;
6364 int retval = 0;
6365 char_u *path;
6366 char_u *tbuf;
6367 char *mesg = NULL;
6368 char *mesg2 = "";
6369 int helpmesg = FALSE;
6370 int reload = FALSE;
6371 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6372 int can_reload = FALSE;
6373 #endif
6374 size_t orig_size = buf->b_orig_size;
6375 int orig_mode = buf->b_orig_mode;
6376 #ifdef FEAT_GUI
6377 int save_mouse_correct = need_mouse_correct;
6378 #endif
6379 #ifdef FEAT_AUTOCMD
6380 static int busy = FALSE;
6381 int n;
6382 char_u *s;
6383 #endif
6384 char *reason;
6385
6386 /* If there is no file name, the buffer is not loaded, 'buftype' is
6387 * set, we are in the middle of a save or being called recursively: ignore
6388 * this buffer. */
6389 if (buf->b_ffname == NULL
6390 || buf->b_ml.ml_mfp == NULL
6391 #if defined(FEAT_QUICKFIX)
6392 || *buf->b_p_bt != NUL
6393 #endif
6394 || buf->b_saving
6395 #ifdef FEAT_AUTOCMD
6396 || busy
6397 #endif
6398 #ifdef FEAT_NETBEANS_INTG
6399 || isNetbeansBuffer(buf)
6400 #endif
6401 )
6402 return 0;
6403
6404 if ( !(buf->b_flags & BF_NOTEDITED)
6405 && buf->b_mtime != 0
6406 && ((stat_res = mch_stat((char *)buf->b_ffname, &st)) < 0
6407 || time_differs((long)st.st_mtime, buf->b_mtime)
6408 #ifdef HAVE_ST_MODE
6409 || (int)st.st_mode != buf->b_orig_mode
6410 #else
6411 || mch_getperm(buf->b_ffname) != buf->b_orig_mode
6412 #endif
6413 ))
6414 {
6415 retval = 1;
6416
6417 /* set b_mtime to stop further warnings (e.g., when executing
6418 * FileChangedShell autocmd) */
6419 if (stat_res < 0)
6420 {
6421 buf->b_mtime = 0;
6422 buf->b_orig_size = 0;
6423 buf->b_orig_mode = 0;
6424 }
6425 else
6426 buf_store_time(buf, &st, buf->b_ffname);
6427
6428 /* Don't do anything for a directory. Might contain the file
6429 * explorer. */
6430 if (mch_isdir(buf->b_fname))
6431 ;
6432
6433 /*
6434 * If 'autoread' is set, the buffer has no changes and the file still
6435 * exists, reload the buffer. Use the buffer-local option value if it
6436 * was set, the global option value otherwise.
6437 */
6438 else if ((buf->b_p_ar >= 0 ? buf->b_p_ar : p_ar)
6439 && !bufIsChanged(buf) && stat_res >= 0)
6440 reload = TRUE;
6441 else
6442 {
6443 if (stat_res < 0)
6444 reason = "deleted";
6445 else if (bufIsChanged(buf))
6446 reason = "conflict";
6447 else if (orig_size != buf->b_orig_size || buf_contents_changed(buf))
6448 reason = "changed";
6449 else if (orig_mode != buf->b_orig_mode)
6450 reason = "mode";
6451 else
6452 reason = "time";
6453
6454 #ifdef FEAT_AUTOCMD
6455 /*
6456 * Only give the warning if there are no FileChangedShell
6457 * autocommands.
6458 * Avoid being called recursively by setting "busy".
6459 */
6460 busy = TRUE;
6461 # ifdef FEAT_EVAL
6462 set_vim_var_string(VV_FCS_REASON, (char_u *)reason, -1);
6463 set_vim_var_string(VV_FCS_CHOICE, (char_u *)"", -1);
6464 # endif
6465 n = apply_autocmds(EVENT_FILECHANGEDSHELL,
6466 buf->b_fname, buf->b_fname, FALSE, buf);
6467 busy = FALSE;
6468 if (n)
6469 {
6470 if (!buf_valid(buf))
6471 EMSG(_("E246: FileChangedShell autocommand deleted buffer"));
6472 # ifdef FEAT_EVAL
6473 s = get_vim_var_str(VV_FCS_CHOICE);
6474 if (STRCMP(s, "reload") == 0 && *reason != 'd')
6475 reload = TRUE;
6476 else if (STRCMP(s, "ask") == 0)
6477 n = FALSE;
6478 else
6479 # endif
6480 return 2;
6481 }
6482 if (!n)
6483 #endif
6484 {
6485 if (*reason == 'd')
6486 mesg = _("E211: File \"%s\" no longer available");
6487 else
6488 {
6489 helpmesg = TRUE;
6490 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6491 can_reload = TRUE;
6492 #endif
6493 /*
6494 * Check if the file contents really changed to avoid
6495 * giving a warning when only the timestamp was set (e.g.,
6496 * checked out of CVS). Always warn when the buffer was
6497 * changed.
6498 */
6499 if (reason[2] == 'n')
6500 {
6501 mesg = _("W12: Warning: File \"%s\" has changed and the buffer was changed in Vim as well");
6502 mesg2 = _("See \":help W12\" for more info.");
6503 }
6504 else if (reason[1] == 'h')
6505 {
6506 mesg = _("W11: Warning: File \"%s\" has changed since editing started");
6507 mesg2 = _("See \":help W11\" for more info.");
6508 }
6509 else if (*reason == 'm')
6510 {
6511 mesg = _("W16: Warning: Mode of file \"%s\" has changed since editing started");
6512 mesg2 = _("See \":help W16\" for more info.");
6513 }
6514 /* Else: only timestamp changed, ignored */
6515 }
6516 }
6517 }
6518
6519 }
6520 else if ((buf->b_flags & BF_NEW) && !(buf->b_flags & BF_NEW_W)
6521 && vim_fexists(buf->b_ffname))
6522 {
6523 retval = 1;
6524 mesg = _("W13: Warning: File \"%s\" has been created after editing started");
6525 buf->b_flags |= BF_NEW_W;
6526 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6527 can_reload = TRUE;
6528 #endif
6529 }
6530
6531 if (mesg != NULL)
6532 {
6533 path = home_replace_save(buf, buf->b_fname);
6534 if (path != NULL)
6535 {
6536 if (!helpmesg)
6537 mesg2 = "";
6538 tbuf = alloc((unsigned)(STRLEN(path) + STRLEN(mesg)
6539 + STRLEN(mesg2) + 2));
6540 sprintf((char *)tbuf, mesg, path);
6541 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6542 if (can_reload)
6543 {
6544 if (*mesg2 != NUL)
6545 {
6546 STRCAT(tbuf, "\n");
6547 STRCAT(tbuf, mesg2);
6548 }
6549 if (do_dialog(VIM_WARNING, (char_u *)_("Warning"), tbuf,
6550 (char_u *)_("&OK\n&Load File"), 1, NULL) == 2)
6551 reload = TRUE;
6552 }
6553 else
6554 #endif
6555 if (State > NORMAL_BUSY || (State & CMDLINE) || already_warned)
6556 {
6557 if (*mesg2 != NUL)
6558 {
6559 STRCAT(tbuf, "; ");
6560 STRCAT(tbuf, mesg2);
6561 }
6562 EMSG(tbuf);
6563 retval = 2;
6564 }
6565 else
6566 {
6567 # ifdef FEAT_AUTOCMD
6568 if (!autocmd_busy)
6569 # endif
6570 {
6571 msg_start();
6572 msg_puts_attr(tbuf, hl_attr(HLF_E) + MSG_HIST);
6573 if (*mesg2 != NUL)
6574 msg_puts_attr((char_u *)mesg2,
6575 hl_attr(HLF_W) + MSG_HIST);
6576 msg_clr_eos();
6577 (void)msg_end();
6578 if (emsg_silent == 0)
6579 {
6580 out_flush();
6581 # ifdef FEAT_GUI
6582 if (!focus)
6583 # endif
6584 /* give the user some time to think about it */
6585 ui_delay(1000L, TRUE);
6586
6587 /* don't redraw and erase the message */
6588 redraw_cmdline = FALSE;
6589 }
6590 }
6591 already_warned = TRUE;
6592 }
6593
6594 vim_free(path);
6595 vim_free(tbuf);
6596 }
6597 }
6598
6599 if (reload)
6600 /* Reload the buffer. */
6601 buf_reload(buf, orig_mode);
6602
6603 #ifdef FEAT_AUTOCMD
6604 /* Trigger FileChangedShell when the file was changed in any way. */
6605 if (buf_valid(buf) && retval != 0)
6606 (void)apply_autocmds(EVENT_FILECHANGEDSHELLPOST,
6607 buf->b_fname, buf->b_fname, FALSE, buf);
6608 #endif
6609 #ifdef FEAT_GUI
6610 /* restore this in case an autocommand has set it; it would break
6611 * 'mousefocus' */
6612 need_mouse_correct = save_mouse_correct;
6613 #endif
6614
6615 return retval;
6616 }
6617
6618 /*
6619 * Reload a buffer that is already loaded.
6620 * Used when the file was changed outside of Vim.
6621 * "orig_mode" is buf->b_orig_mode before the need for reloading was detected.
6622 * buf->b_orig_mode may have been reset already.
6623 */
6624 void
6625 buf_reload(buf, orig_mode)
6626 buf_T *buf;
6627 int orig_mode;
6628 {
6629 exarg_T ea;
6630 pos_T old_cursor;
6631 linenr_T old_topline;
6632 int old_ro = buf->b_p_ro;
6633 buf_T *savebuf;
6634 int saved = OK;
6635 aco_save_T aco;
6636
6637 /* set curwin/curbuf for "buf" and save some things */
6638 aucmd_prepbuf(&aco, buf);
6639
6640 /* We only want to read the text from the file, not reset the syntax
6641 * highlighting, clear marks, diff status, etc. Force the fileformat
6642 * and encoding to be the same. */
6643 if (prep_exarg(&ea, buf) == OK)
6644 {
6645 old_cursor = curwin->w_cursor;
6646 old_topline = curwin->w_topline;
6647
6648 /*
6649 * To behave like when a new file is edited (matters for
6650 * BufReadPost autocommands) we first need to delete the current
6651 * buffer contents. But if reading the file fails we should keep
6652 * the old contents. Can't use memory only, the file might be
6653 * too big. Use a hidden buffer to move the buffer contents to.
6654 */
6655 if (bufempty())
6656 savebuf = NULL;
6657 else
6658 {
6659 /* Allocate a buffer without putting it in the buffer list. */
6660 savebuf = buflist_new(NULL, NULL, (linenr_T)1, BLN_DUMMY);
6661 if (savebuf != NULL && buf == curbuf)
6662 {
6663 /* Open the memline. */
6664 curbuf = savebuf;
6665 curwin->w_buffer = savebuf;
6666 saved = ml_open(curbuf);
6667 curbuf = buf;
6668 curwin->w_buffer = buf;
6669 }
6670 if (savebuf == NULL || saved == FAIL || buf != curbuf
6671 || move_lines(buf, savebuf) == FAIL)
6672 {
6673 EMSG2(_("E462: Could not prepare for reloading \"%s\""),
6674 buf->b_fname);
6675 saved = FAIL;
6676 }
6677 }
6678
6679 if (saved == OK)
6680 {
6681 curbuf->b_flags |= BF_CHECK_RO; /* check for RO again */
6682 #ifdef FEAT_AUTOCMD
6683 keep_filetype = TRUE; /* don't detect 'filetype' */
6684 #endif
6685 if (readfile(buf->b_ffname, buf->b_fname, (linenr_T)0,
6686 (linenr_T)0,
6687 (linenr_T)MAXLNUM, &ea, READ_NEW) == FAIL)
6688 {
6689 #if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
6690 if (!aborting())
6691 #endif
6692 EMSG2(_("E321: Could not reload \"%s\""), buf->b_fname);
6693 if (savebuf != NULL && buf_valid(savebuf) && buf == curbuf)
6694 {
6695 /* Put the text back from the save buffer. First
6696 * delete any lines that readfile() added. */
6697 while (!bufempty())
6698 if (ml_delete(buf->b_ml.ml_line_count, FALSE) == FAIL)
6699 break;
6700 (void)move_lines(savebuf, buf);
6701 }
6702 }
6703 else if (buf == curbuf)
6704 {
6705 /* Mark the buffer as unmodified and free undo info. */
6706 unchanged(buf, TRUE);
6707 u_blockfree(buf);
6708 u_clearall(buf);
6709 }
6710 }
6711 vim_free(ea.cmd);
6712
6713 if (savebuf != NULL && buf_valid(savebuf))
6714 wipe_buffer(savebuf, FALSE);
6715
6716 #ifdef FEAT_DIFF
6717 /* Invalidate diff info if necessary. */
6718 diff_invalidate(curbuf);
6719 #endif
6720
6721 /* Restore the topline and cursor position and check it (lines may
6722 * have been removed). */
6723 if (old_topline > curbuf->b_ml.ml_line_count)
6724 curwin->w_topline = curbuf->b_ml.ml_line_count;
6725 else
6726 curwin->w_topline = old_topline;
6727 curwin->w_cursor = old_cursor;
6728 check_cursor();
6729 update_topline();
6730 #ifdef FEAT_AUTOCMD
6731 keep_filetype = FALSE;
6732 #endif
6733 #ifdef FEAT_FOLDING
6734 {
6735 win_T *wp;
6736
6737 /* Update folds unless they are defined manually. */
6738 FOR_ALL_WINDOWS(wp)
6739 if (wp->w_buffer == curwin->w_buffer
6740 && !foldmethodIsManual(wp))
6741 foldUpdateAll(wp);
6742 }
6743 #endif
6744 /* If the mode didn't change and 'readonly' was set, keep the old
6745 * value; the user probably used the ":view" command. But don't
6746 * reset it, might have had a read error. */
6747 if (orig_mode == curbuf->b_orig_mode)
6748 curbuf->b_p_ro |= old_ro;
6749 }
6750
6751 /* restore curwin/curbuf and a few other things */
6752 aucmd_restbuf(&aco);
6753 /* Careful: autocommands may have made "buf" invalid! */
6754 }
6755
6756 /*ARGSUSED*/
6757 void
6758 buf_store_time(buf, st, fname)
6759 buf_T *buf;
6760 struct stat *st;
6761 char_u *fname;
6762 {
6763 buf->b_mtime = (long)st->st_mtime;
6764 buf->b_orig_size = (size_t)st->st_size;
6765 #ifdef HAVE_ST_MODE
6766 buf->b_orig_mode = (int)st->st_mode;
6767 #else
6768 buf->b_orig_mode = mch_getperm(fname);
6769 #endif
6770 }
6771
6772 /*
6773 * Adjust the line with missing eol, used for the next write.
6774 * Used for do_filter(), when the input lines for the filter are deleted.
6775 */
6776 void
6777 write_lnum_adjust(offset)
6778 linenr_T offset;
6779 {
6780 if (write_no_eol_lnum != 0) /* only if there is a missing eol */
6781 write_no_eol_lnum += offset;
6782 }
6783
6784 #if defined(TEMPDIRNAMES) || defined(PROTO)
6785 static long temp_count = 0; /* Temp filename counter. */
6786
6787 /*
6788 * Delete the temp directory and all files it contains.
6789 */
6790 void
6791 vim_deltempdir()
6792 {
6793 char_u **files;
6794 int file_count;
6795 int i;
6796
6797 if (vim_tempdir != NULL)
6798 {
6799 sprintf((char *)NameBuff, "%s*", vim_tempdir);
6800 if (gen_expand_wildcards(1, &NameBuff, &file_count, &files,
6801 EW_DIR|EW_FILE|EW_SILENT) == OK)
6802 {
6803 for (i = 0; i < file_count; ++i)
6804 mch_remove(files[i]);
6805 FreeWild(file_count, files);
6806 }
6807 gettail(NameBuff)[-1] = NUL;
6808 (void)mch_rmdir(NameBuff);
6809
6810 vim_free(vim_tempdir);
6811 vim_tempdir = NULL;
6812 }
6813 }
6814 #endif
6815
6816 /*
6817 * vim_tempname(): Return a unique name that can be used for a temp file.
6818 *
6819 * The temp file is NOT created.
6820 *
6821 * The returned pointer is to allocated memory.
6822 * The returned pointer is NULL if no valid name was found.
6823 */
6824 /*ARGSUSED*/
6825 char_u *
6826 vim_tempname(extra_char)
6827 int extra_char; /* character to use in the name instead of '?' */
6828 {
6829 #ifdef USE_TMPNAM
6830 char_u itmp[L_tmpnam]; /* use tmpnam() */
6831 #else
6832 char_u itmp[TEMPNAMELEN];
6833 #endif
6834
6835 #ifdef TEMPDIRNAMES
6836 static char *(tempdirs[]) = {TEMPDIRNAMES};
6837 int i;
6838 long nr;
6839 long off;
6840 # ifndef EEXIST
6841 struct stat st;
6842 # endif
6843
6844 /*
6845 * This will create a directory for private use by this instance of Vim.
6846 * This is done once, and the same directory is used for all temp files.
6847 * This method avoids security problems because of symlink attacks et al.
6848 * It's also a bit faster, because we only need to check for an existing
6849 * file when creating the directory and not for each temp file.
6850 */
6851 if (vim_tempdir == NULL)
6852 {
6853 /*
6854 * Try the entries in TEMPDIRNAMES to create the temp directory.
6855 */
6856 for (i = 0; i < sizeof(tempdirs) / sizeof(char *); ++i)
6857 {
6858 /* expand $TMP, leave room for "/v1100000/999999999" */
6859 expand_env((char_u *)tempdirs[i], itmp, TEMPNAMELEN - 20);
6860 if (mch_isdir(itmp)) /* directory exists */
6861 {
6862 # ifdef __EMX__
6863 /* If $TMP contains a forward slash (perhaps using bash or
6864 * tcsh), don't add a backslash, use a forward slash!
6865 * Adding 2 backslashes didn't work. */
6866 if (vim_strchr(itmp, '/') != NULL)
6867 STRCAT(itmp, "/");
6868 else
6869 # endif
6870 add_pathsep(itmp);
6871
6872 /* Get an arbitrary number of up to 6 digits. When it's
6873 * unlikely that it already exists it will be faster,
6874 * otherwise it doesn't matter. The use of mkdir() avoids any
6875 * security problems because of the predictable number. */
6876 nr = (mch_get_pid() + (long)time(NULL)) % 1000000L;
6877
6878 /* Try up to 10000 different values until we find a name that
6879 * doesn't exist. */
6880 for (off = 0; off < 10000L; ++off)
6881 {
6882 int r;
6883 #if defined(UNIX) || defined(VMS)
6884 mode_t umask_save;
6885 #endif
6886
6887 sprintf((char *)itmp + STRLEN(itmp), "v%ld", nr + off);
6888 # ifndef EEXIST
6889 /* If mkdir() does not set errno to EEXIST, check for
6890 * existing file here. There is a race condition then,
6891 * although it's fail-safe. */
6892 if (mch_stat((char *)itmp, &st) >= 0)
6893 continue;
6894 # endif
6895 #if defined(UNIX) || defined(VMS)
6896 /* Make sure the umask doesn't remove the executable bit.
6897 * "repl" has been reported to use "177". */
6898 umask_save = umask(077);
6899 #endif
6900 r = vim_mkdir(itmp, 0700);
6901 #if defined(UNIX) || defined(VMS)
6902 (void)umask(umask_save);
6903 #endif
6904 if (r == 0)
6905 {
6906 char_u *buf;
6907
6908 /* Directory was created, use this name.
6909 * Expand to full path; When using the current
6910 * directory a ":cd" would confuse us. */
6911 buf = alloc((unsigned)MAXPATHL + 1);
6912 if (buf != NULL)
6913 {
6914 if (vim_FullName(itmp, buf, MAXPATHL, FALSE)
6915 == FAIL)
6916 STRCPY(buf, itmp);
6917 # ifdef __EMX__
6918 if (vim_strchr(buf, '/') != NULL)
6919 STRCAT(buf, "/");
6920 else
6921 # endif
6922 add_pathsep(buf);
6923 vim_tempdir = vim_strsave(buf);
6924 vim_free(buf);
6925 }
6926 break;
6927 }
6928 # ifdef EEXIST
6929 /* If the mkdir() didn't fail because the file/dir exists,
6930 * we probably can't create any dir here, try another
6931 * place. */
6932 if (errno != EEXIST)
6933 # endif
6934 break;
6935 }
6936 if (vim_tempdir != NULL)
6937 break;
6938 }
6939 }
6940 }
6941
6942 if (vim_tempdir != NULL)
6943 {
6944 /* There is no need to check if the file exists, because we own the
6945 * directory and nobody else creates a file in it. */
6946 sprintf((char *)itmp, "%s%ld", vim_tempdir, temp_count++);
6947 return vim_strsave(itmp);
6948 }
6949
6950 return NULL;
6951
6952 #else /* TEMPDIRNAMES */
6953
6954 # ifdef WIN3264
6955 char szTempFile[_MAX_PATH + 1];
6956 char buf4[4];
6957 char_u *retval;
6958 char_u *p;
6959
6960 STRCPY(itmp, "");
6961 if (GetTempPath(_MAX_PATH, szTempFile) == 0)
6962 szTempFile[0] = NUL; /* GetTempPath() failed, use current dir */
6963 strcpy(buf4, "VIM");
6964 buf4[2] = extra_char; /* make it "VIa", "VIb", etc. */
6965 if (GetTempFileName(szTempFile, buf4, 0, itmp) == 0)
6966 return NULL;
6967 /* GetTempFileName() will create the file, we don't want that */
6968 (void)DeleteFile(itmp);
6969
6970 /* Backslashes in a temp file name cause problems when filtering with
6971 * "sh". NOTE: This also checks 'shellcmdflag' to help those people who
6972 * didn't set 'shellslash'. */
6973 retval = vim_strsave(itmp);
6974 if (*p_shcf == '-' || p_ssl)
6975 for (p = retval; *p; ++p)
6976 if (*p == '\\')
6977 *p = '/';
6978 return retval;
6979
6980 # else /* WIN3264 */
6981
6982 # ifdef USE_TMPNAM
6983 /* tmpnam() will make its own name */
6984 if (*tmpnam((char *)itmp) == NUL)
6985 return NULL;
6986 # else
6987 char_u *p;
6988
6989 # ifdef VMS_TEMPNAM
6990 /* mktemp() is not working on VMS. It seems to be
6991 * a do-nothing function. Therefore we use tempnam().
6992 */
6993 sprintf((char *)itmp, "VIM%c", extra_char);
6994 p = (char_u *)tempnam("tmp:", (char *)itmp);
6995 if (p != NULL)
6996 {
6997 /* VMS will use '.LOG' if we don't explicitly specify an extension,
6998 * and VIM will then be unable to find the file later */
6999 STRCPY(itmp, p);
7000 STRCAT(itmp, ".txt");
7001 free(p);
7002 }
7003 else
7004 return NULL;
7005 # else
7006 STRCPY(itmp, TEMPNAME);
7007 if ((p = vim_strchr(itmp, '?')) != NULL)
7008 *p = extra_char;
7009 if (mktemp((char *)itmp) == NULL)
7010 return NULL;
7011 # endif
7012 # endif
7013
7014 return vim_strsave(itmp);
7015 # endif /* WIN3264 */
7016 #endif /* TEMPDIRNAMES */
7017 }
7018
7019 #if defined(BACKSLASH_IN_FILENAME) || defined(PROTO)
7020 /*
7021 * Convert all backslashes in fname to forward slashes in-place.
7022 */
7023 void
7024 forward_slash(fname)
7025 char_u *fname;
7026 {
7027 char_u *p;
7028
7029 for (p = fname; *p != NUL; ++p)
7030 # ifdef FEAT_MBYTE
7031 /* The Big5 encoding can have '\' in the trail byte. */
7032 if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
7033 ++p;
7034 else
7035 # endif
7036 if (*p == '\\')
7037 *p = '/';
7038 }
7039 #endif
7040
7041
7042 /*
7043 * Code for automatic commands.
7044 *
7045 * Only included when "FEAT_AUTOCMD" has been defined.
7046 */
7047
7048 #if defined(FEAT_AUTOCMD) || defined(PROTO)
7049
7050 /*
7051 * The autocommands are stored in a list for each event.
7052 * Autocommands for the same pattern, that are consecutive, are joined
7053 * together, to avoid having to match the pattern too often.
7054 * The result is an array of Autopat lists, which point to AutoCmd lists:
7055 *
7056 * first_autopat[0] --> Autopat.next --> Autopat.next --> NULL
7057 * Autopat.cmds Autopat.cmds
7058 * | |
7059 * V V
7060 * AutoCmd.next AutoCmd.next
7061 * | |
7062 * V V
7063 * AutoCmd.next NULL
7064 * |
7065 * V
7066 * NULL
7067 *
7068 * first_autopat[1] --> Autopat.next --> NULL
7069 * Autopat.cmds
7070 * |
7071 * V
7072 * AutoCmd.next
7073 * |
7074 * V
7075 * NULL
7076 * etc.
7077 *
7078 * The order of AutoCmds is important, this is the order in which they were
7079 * defined and will have to be executed.
7080 */
7081 typedef struct AutoCmd
7082 {
7083 char_u *cmd; /* The command to be executed (NULL
7084 when command has been removed) */
7085 char nested; /* If autocommands nest here */
7086 char last; /* last command in list */
7087 #ifdef FEAT_EVAL
7088 scid_T scriptID; /* script ID where defined */
7089 #endif
7090 struct AutoCmd *next; /* Next AutoCmd in list */
7091 } AutoCmd;
7092
7093 typedef struct AutoPat
7094 {
7095 int group; /* group ID */
7096 char_u *pat; /* pattern as typed (NULL when pattern
7097 has been removed) */
7098 int patlen; /* strlen() of pat */
7099 regprog_T *reg_prog; /* compiled regprog for pattern */
7100 char allow_dirs; /* Pattern may match whole path */
7101 char last; /* last pattern for apply_autocmds() */
7102 AutoCmd *cmds; /* list of commands to do */
7103 struct AutoPat *next; /* next AutoPat in AutoPat list */
7104 int buflocal_nr; /* !=0 for buffer-local AutoPat */
7105 } AutoPat;
7106
7107 static struct event_name
7108 {
7109 char *name; /* event name */
7110 event_T event; /* event number */
7111 } event_names[] =
7112 {
7113 {"BufAdd", EVENT_BUFADD},
7114 {"BufCreate", EVENT_BUFADD},
7115 {"BufDelete", EVENT_BUFDELETE},
7116 {"BufEnter", EVENT_BUFENTER},
7117 {"BufFilePost", EVENT_BUFFILEPOST},
7118 {"BufFilePre", EVENT_BUFFILEPRE},
7119 {"BufHidden", EVENT_BUFHIDDEN},
7120 {"BufLeave", EVENT_BUFLEAVE},
7121 {"BufNew", EVENT_BUFNEW},
7122 {"BufNewFile", EVENT_BUFNEWFILE},
7123 {"BufRead", EVENT_BUFREADPOST},
7124 {"BufReadCmd", EVENT_BUFREADCMD},
7125 {"BufReadPost", EVENT_BUFREADPOST},
7126 {"BufReadPre", EVENT_BUFREADPRE},
7127 {"BufUnload", EVENT_BUFUNLOAD},
7128 {"BufWinEnter", EVENT_BUFWINENTER},
7129 {"BufWinLeave", EVENT_BUFWINLEAVE},
7130 {"BufWipeout", EVENT_BUFWIPEOUT},
7131 {"BufWrite", EVENT_BUFWRITEPRE},
7132 {"BufWritePost", EVENT_BUFWRITEPOST},
7133 {"BufWritePre", EVENT_BUFWRITEPRE},
7134 {"BufWriteCmd", EVENT_BUFWRITECMD},
7135 {"CmdwinEnter", EVENT_CMDWINENTER},
7136 {"CmdwinLeave", EVENT_CMDWINLEAVE},
7137 {"ColorScheme", EVENT_COLORSCHEME},
7138 {"CursorHold", EVENT_CURSORHOLD},
7139 {"CursorHoldI", EVENT_CURSORHOLDI},
7140 {"CursorMoved", EVENT_CURSORMOVED},
7141 {"CursorMovedI", EVENT_CURSORMOVEDI},
7142 {"EncodingChanged", EVENT_ENCODINGCHANGED},
7143 {"FileEncoding", EVENT_ENCODINGCHANGED},
7144 {"FileAppendPost", EVENT_FILEAPPENDPOST},
7145 {"FileAppendPre", EVENT_FILEAPPENDPRE},
7146 {"FileAppendCmd", EVENT_FILEAPPENDCMD},
7147 {"FileChangedShell",EVENT_FILECHANGEDSHELL},
7148 {"FileChangedShellPost",EVENT_FILECHANGEDSHELLPOST},
7149 {"FileChangedRO", EVENT_FILECHANGEDRO},
7150 {"FileReadPost", EVENT_FILEREADPOST},
7151 {"FileReadPre", EVENT_FILEREADPRE},
7152 {"FileReadCmd", EVENT_FILEREADCMD},
7153 {"FileType", EVENT_FILETYPE},
7154 {"FileWritePost", EVENT_FILEWRITEPOST},
7155 {"FileWritePre", EVENT_FILEWRITEPRE},
7156 {"FileWriteCmd", EVENT_FILEWRITECMD},
7157 {"FilterReadPost", EVENT_FILTERREADPOST},
7158 {"FilterReadPre", EVENT_FILTERREADPRE},
7159 {"FilterWritePost", EVENT_FILTERWRITEPOST},
7160 {"FilterWritePre", EVENT_FILTERWRITEPRE},
7161 {"FocusGained", EVENT_FOCUSGAINED},
7162 {"FocusLost", EVENT_FOCUSLOST},
7163 {"FuncUndefined", EVENT_FUNCUNDEFINED},
7164 {"GUIEnter", EVENT_GUIENTER},
7165 {"GUIFailed", EVENT_GUIFAILED},
7166 {"InsertChange", EVENT_INSERTCHANGE},
7167 {"InsertEnter", EVENT_INSERTENTER},
7168 {"InsertLeave", EVENT_INSERTLEAVE},
7169 {"MenuPopup", EVENT_MENUPOPUP},
7170 {"QuickFixCmdPost", EVENT_QUICKFIXCMDPOST},
7171 {"QuickFixCmdPre", EVENT_QUICKFIXCMDPRE},
7172 {"RemoteReply", EVENT_REMOTEREPLY},
7173 {"SessionLoadPost", EVENT_SESSIONLOADPOST},
7174 {"ShellCmdPost", EVENT_SHELLCMDPOST},
7175 {"ShellFilterPost", EVENT_SHELLFILTERPOST},
7176 {"SourcePre", EVENT_SOURCEPRE},
7177 {"SourceCmd", EVENT_SOURCECMD},
7178 {"SpellFileMissing",EVENT_SPELLFILEMISSING},
7179 {"StdinReadPost", EVENT_STDINREADPOST},
7180 {"StdinReadPre", EVENT_STDINREADPRE},
7181 {"SwapExists", EVENT_SWAPEXISTS},
7182 {"Syntax", EVENT_SYNTAX},
7183 {"TabEnter", EVENT_TABENTER},
7184 {"TabLeave", EVENT_TABLEAVE},
7185 {"TermChanged", EVENT_TERMCHANGED},
7186 {"TermResponse", EVENT_TERMRESPONSE},
7187 {"User", EVENT_USER},
7188 {"VimEnter", EVENT_VIMENTER},
7189 {"VimLeave", EVENT_VIMLEAVE},
7190 {"VimLeavePre", EVENT_VIMLEAVEPRE},
7191 {"WinEnter", EVENT_WINENTER},
7192 {"WinLeave", EVENT_WINLEAVE},
7193 {"VimResized", EVENT_VIMRESIZED},
7194 {NULL, (event_T)0}
7195 };
7196
7197 static AutoPat *first_autopat[NUM_EVENTS] =
7198 {
7199 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7200 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7201 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7202 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7203 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7204 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
7205 };
7206
7207 /*
7208 * struct used to keep status while executing autocommands for an event.
7209 */
7210 typedef struct AutoPatCmd
7211 {
7212 AutoPat *curpat; /* next AutoPat to examine */
7213 AutoCmd *nextcmd; /* next AutoCmd to execute */
7214 int group; /* group being used */
7215 char_u *fname; /* fname to match with */
7216 char_u *sfname; /* sfname to match with */
7217 char_u *tail; /* tail of fname */
7218 event_T event; /* current event */
7219 int arg_bufnr; /* initially equal to <abuf>, set to zero when
7220 buf is deleted */
7221 struct AutoPatCmd *next; /* chain of active apc-s for auto-invalidation*/
7222 } AutoPatCmd;
7223
7224 static AutoPatCmd *active_apc_list = NULL; /* stack of active autocommands */
7225
7226 /*
7227 * augroups stores a list of autocmd group names.
7228 */
7229 static garray_T augroups = {0, 0, sizeof(char_u *), 10, NULL};
7230 #define AUGROUP_NAME(i) (((char_u **)augroups.ga_data)[i])
7231
7232 /*
7233 * The ID of the current group. Group 0 is the default one.
7234 */
7235 static int current_augroup = AUGROUP_DEFAULT;
7236
7237 static int au_need_clean = FALSE; /* need to delete marked patterns */
7238
7239 static void show_autocmd __ARGS((AutoPat *ap, event_T event));
7240 static void au_remove_pat __ARGS((AutoPat *ap));
7241 static void au_remove_cmds __ARGS((AutoPat *ap));
7242 static void au_cleanup __ARGS((void));
7243 static int au_new_group __ARGS((char_u *name));
7244 static void au_del_group __ARGS((char_u *name));
7245 static event_T event_name2nr __ARGS((char_u *start, char_u **end));
7246 static char_u *event_nr2name __ARGS((event_T event));
7247 static char_u *find_end_event __ARGS((char_u *arg, int have_group));
7248 static int event_ignored __ARGS((event_T event));
7249 static int au_get_grouparg __ARGS((char_u **argp));
7250 static int do_autocmd_event __ARGS((event_T event, char_u *pat, int nested, char_u *cmd, int forceit, int group));
7251 static char_u *getnextac __ARGS((int c, void *cookie, int indent));
7252 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));
7253 static void auto_next_pat __ARGS((AutoPatCmd *apc, int stop_at_last));
7254
7255
7256 static event_T last_event;
7257 static int last_group;
7258 static int autocmd_blocked = 0; /* block all autocmds */
7259
7260 /*
7261 * Show the autocommands for one AutoPat.
7262 */
7263 static void
7264 show_autocmd(ap, event)
7265 AutoPat *ap;
7266 event_T event;
7267 {
7268 AutoCmd *ac;
7269
7270 /* Check for "got_int" (here and at various places below), which is set
7271 * when "q" has been hit for the "--more--" prompt */
7272 if (got_int)
7273 return;
7274 if (ap->pat == NULL) /* pattern has been removed */
7275 return;
7276
7277 msg_putchar('\n');
7278 if (got_int)
7279 return;
7280 if (event != last_event || ap->group != last_group)
7281 {
7282 if (ap->group != AUGROUP_DEFAULT)
7283 {
7284 if (AUGROUP_NAME(ap->group) == NULL)
7285 msg_puts_attr((char_u *)_("--Deleted--"), hl_attr(HLF_E));
7286 else
7287 msg_puts_attr(AUGROUP_NAME(ap->group), hl_attr(HLF_T));
7288 msg_puts((char_u *)" ");
7289 }
7290 msg_puts_attr(event_nr2name(event), hl_attr(HLF_T));
7291 last_event = event;
7292 last_group = ap->group;
7293 msg_putchar('\n');
7294 if (got_int)
7295 return;
7296 }
7297 msg_col = 4;
7298 msg_outtrans(ap->pat);
7299
7300 for (ac = ap->cmds; ac != NULL; ac = ac->next)
7301 {
7302 if (ac->cmd != NULL) /* skip removed commands */
7303 {
7304 if (msg_col >= 14)
7305 msg_putchar('\n');
7306 msg_col = 14;
7307 if (got_int)
7308 return;
7309 msg_outtrans(ac->cmd);
7310 #ifdef FEAT_EVAL
7311 if (p_verbose > 0)
7312 last_set_msg(ac->scriptID);
7313 #endif
7314 if (got_int)
7315 return;
7316 if (ac->next != NULL)
7317 {
7318 msg_putchar('\n');
7319 if (got_int)
7320 return;
7321 }
7322 }
7323 }
7324 }
7325
7326 /*
7327 * Mark an autocommand pattern for deletion.
7328 */
7329 static void
7330 au_remove_pat(ap)
7331 AutoPat *ap;
7332 {
7333 vim_free(ap->pat);
7334 ap->pat = NULL;
7335 ap->buflocal_nr = -1;
7336 au_need_clean = TRUE;
7337 }
7338
7339 /*
7340 * Mark all commands for a pattern for deletion.
7341 */
7342 static void
7343 au_remove_cmds(ap)
7344 AutoPat *ap;
7345 {
7346 AutoCmd *ac;
7347
7348 for (ac = ap->cmds; ac != NULL; ac = ac->next)
7349 {
7350 vim_free(ac->cmd);
7351 ac->cmd = NULL;
7352 }
7353 au_need_clean = TRUE;
7354 }
7355
7356 /*
7357 * Cleanup autocommands and patterns that have been deleted.
7358 * This is only done when not executing autocommands.
7359 */
7360 static void
7361 au_cleanup()
7362 {
7363 AutoPat *ap, **prev_ap;
7364 AutoCmd *ac, **prev_ac;
7365 event_T event;
7366
7367 if (autocmd_busy || !au_need_clean)
7368 return;
7369
7370 /* loop over all events */
7371 for (event = (event_T)0; (int)event < (int)NUM_EVENTS;
7372 event = (event_T)((int)event + 1))
7373 {
7374 /* loop over all autocommand patterns */
7375 prev_ap = &(first_autopat[(int)event]);
7376 for (ap = *prev_ap; ap != NULL; ap = *prev_ap)
7377 {
7378 /* loop over all commands for this pattern */
7379 prev_ac = &(ap->cmds);
7380 for (ac = *prev_ac; ac != NULL; ac = *prev_ac)
7381 {
7382 /* remove the command if the pattern is to be deleted or when
7383 * the command has been marked for deletion */
7384 if (ap->pat == NULL || ac->cmd == NULL)
7385 {
7386 *prev_ac = ac->next;
7387 vim_free(ac->cmd);
7388 vim_free(ac);
7389 }
7390 else
7391 prev_ac = &(ac->next);
7392 }
7393
7394 /* remove the pattern if it has been marked for deletion */
7395 if (ap->pat == NULL)
7396 {
7397 *prev_ap = ap->next;
7398 vim_free(ap->reg_prog);
7399 vim_free(ap);
7400 }
7401 else
7402 prev_ap = &(ap->next);
7403 }
7404 }
7405
7406 au_need_clean = FALSE;
7407 }
7408
7409 /*
7410 * Called when buffer is freed, to remove/invalidate related buffer-local
7411 * autocmds.
7412 */
7413 void
7414 aubuflocal_remove(buf)
7415 buf_T *buf;
7416 {
7417 AutoPat *ap;
7418 event_T event;
7419 AutoPatCmd *apc;
7420
7421 /* invalidate currently executing autocommands */
7422 for (apc = active_apc_list; apc; apc = apc->next)
7423 if (buf->b_fnum == apc->arg_bufnr)
7424 apc->arg_bufnr = 0;
7425
7426 /* invalidate buflocals looping through events */
7427 for (event = (event_T)0; (int)event < (int)NUM_EVENTS;
7428 event = (event_T)((int)event + 1))
7429 /* loop over all autocommand patterns */
7430 for (ap = first_autopat[(int)event]; ap != NULL; ap = ap->next)
7431 if (ap->buflocal_nr == buf->b_fnum)
7432 {
7433 au_remove_pat(ap);
7434 if (p_verbose >= 6)
7435 {
7436 verbose_enter();
7437 smsg((char_u *)
7438 _("auto-removing autocommand: %s <buffer=%d>"),
7439 event_nr2name(event), buf->b_fnum);
7440 verbose_leave();
7441 }
7442 }
7443 au_cleanup();
7444 }
7445
7446 /*
7447 * Add an autocmd group name.
7448 * Return it's ID. Returns AUGROUP_ERROR (< 0) for error.
7449 */
7450 static int
7451 au_new_group(name)
7452 char_u *name;
7453 {
7454 int i;
7455
7456 i = au_find_group(name);
7457 if (i == AUGROUP_ERROR) /* the group doesn't exist yet, add it */
7458 {
7459 /* First try using a free entry. */
7460 for (i = 0; i < augroups.ga_len; ++i)
7461 if (AUGROUP_NAME(i) == NULL)
7462 break;
7463 if (i == augroups.ga_len && ga_grow(&augroups, 1) == FAIL)
7464 return AUGROUP_ERROR;
7465
7466 AUGROUP_NAME(i) = vim_strsave(name);
7467 if (AUGROUP_NAME(i) == NULL)
7468 return AUGROUP_ERROR;
7469 if (i == augroups.ga_len)
7470 ++augroups.ga_len;
7471 }
7472
7473 return i;
7474 }
7475
7476 static void
7477 au_del_group(name)
7478 char_u *name;
7479 {
7480 int i;
7481
7482 i = au_find_group(name);
7483 if (i == AUGROUP_ERROR) /* the group doesn't exist */
7484 EMSG2(_("E367: No such group: \"%s\""), name);
7485 else
7486 {
7487 vim_free(AUGROUP_NAME(i));
7488 AUGROUP_NAME(i) = NULL;
7489 }
7490 }
7491
7492 /*
7493 * Find the ID of an autocmd group name.
7494 * Return it's ID. Returns AUGROUP_ERROR (< 0) for error.
7495 */
7496 static int
7497 au_find_group(name)
7498 char_u *name;
7499 {
7500 int i;
7501
7502 for (i = 0; i < augroups.ga_len; ++i)
7503 if (AUGROUP_NAME(i) != NULL && STRCMP(AUGROUP_NAME(i), name) == 0)
7504 return i;
7505 return AUGROUP_ERROR;
7506 }
7507
7508 /*
7509 * Return TRUE if augroup "name" exists.
7510 */
7511 int
7512 au_has_group(name)
7513 char_u *name;
7514 {
7515 return au_find_group(name) != AUGROUP_ERROR;
7516 }
7517
7518 /*
7519 * ":augroup {name}".
7520 */
7521 void
7522 do_augroup(arg, del_group)
7523 char_u *arg;
7524 int del_group;
7525 {
7526 int i;
7527
7528 if (del_group)
7529 {
7530 if (*arg == NUL)
7531 EMSG(_(e_argreq));
7532 else
7533 au_del_group(arg);
7534 }
7535 else if (STRICMP(arg, "end") == 0) /* ":aug end": back to group 0 */
7536 current_augroup = AUGROUP_DEFAULT;
7537 else if (*arg) /* ":aug xxx": switch to group xxx */
7538 {
7539 i = au_new_group(arg);
7540 if (i != AUGROUP_ERROR)
7541 current_augroup = i;
7542 }
7543 else /* ":aug": list the group names */
7544 {
7545 msg_start();
7546 for (i = 0; i < augroups.ga_len; ++i)
7547 {
7548 if (AUGROUP_NAME(i) != NULL)
7549 {
7550 msg_puts(AUGROUP_NAME(i));
7551 msg_puts((char_u *)" ");
7552 }
7553 }
7554 msg_clr_eos();
7555 msg_end();
7556 }
7557 }
7558
7559 #if defined(EXITFREE) || defined(PROTO)
7560 void
7561 free_all_autocmds()
7562 {
7563 for (current_augroup = -1; current_augroup < augroups.ga_len;
7564 ++current_augroup)
7565 do_autocmd((char_u *)"", TRUE);
7566 ga_clear_strings(&augroups);
7567 }
7568 #endif
7569
7570 /*
7571 * Return the event number for event name "start".
7572 * Return NUM_EVENTS if the event name was not found.
7573 * Return a pointer to the next event name in "end".
7574 */
7575 static event_T
7576 event_name2nr(start, end)
7577 char_u *start;
7578 char_u **end;
7579 {
7580 char_u *p;
7581 int i;
7582 int len;
7583
7584 /* the event name ends with end of line, a blank or a comma */
7585 for (p = start; *p && !vim_iswhite(*p) && *p != ','; ++p)
7586 ;
7587 for (i = 0; event_names[i].name != NULL; ++i)
7588 {
7589 len = (int)STRLEN(event_names[i].name);
7590 if (len == p - start && STRNICMP(event_names[i].name, start, len) == 0)
7591 break;
7592 }
7593 if (*p == ',')
7594 ++p;
7595 *end = p;
7596 if (event_names[i].name == NULL)
7597 return NUM_EVENTS;
7598 return event_names[i].event;
7599 }
7600
7601 /*
7602 * Return the name for event "event".
7603 */
7604 static char_u *
7605 event_nr2name(event)
7606 event_T event;
7607 {
7608 int i;
7609
7610 for (i = 0; event_names[i].name != NULL; ++i)
7611 if (event_names[i].event == event)
7612 return (char_u *)event_names[i].name;
7613 return (char_u *)"Unknown";
7614 }
7615
7616 /*
7617 * Scan over the events. "*" stands for all events.
7618 */
7619 static char_u *
7620 find_end_event(arg, have_group)
7621 char_u *arg;
7622 int have_group; /* TRUE when group name was found */
7623 {
7624 char_u *pat;
7625 char_u *p;
7626
7627 if (*arg == '*')
7628 {
7629 if (arg[1] && !vim_iswhite(arg[1]))
7630 {
7631 EMSG2(_("E215: Illegal character after *: %s"), arg);
7632 return NULL;
7633 }
7634 pat = arg + 1;
7635 }
7636 else
7637 {
7638 for (pat = arg; *pat && !vim_iswhite(*pat); pat = p)
7639 {
7640 if ((int)event_name2nr(pat, &p) >= (int)NUM_EVENTS)
7641 {
7642 if (have_group)
7643 EMSG2(_("E216: No such event: %s"), pat);
7644 else
7645 EMSG2(_("E216: No such group or event: %s"), pat);
7646 return NULL;
7647 }
7648 }
7649 }
7650 return pat;
7651 }
7652
7653 /*
7654 * Return TRUE if "event" is included in 'eventignore'.
7655 */
7656 static int
7657 event_ignored(event)
7658 event_T event;
7659 {
7660 char_u *p = p_ei;
7661
7662 while (*p != NUL)
7663 {
7664 if (STRNICMP(p, "all", 3) == 0 && (p[3] == NUL || p[3] == ','))
7665 return TRUE;
7666 if (event_name2nr(p, &p) == event)
7667 return TRUE;
7668 }
7669
7670 return FALSE;
7671 }
7672
7673 /*
7674 * Return OK when the contents of p_ei is valid, FAIL otherwise.
7675 */
7676 int
7677 check_ei()
7678 {
7679 char_u *p = p_ei;
7680
7681 while (*p)
7682 {
7683 if (STRNICMP(p, "all", 3) == 0 && (p[3] == NUL || p[3] == ','))
7684 {
7685 p += 3;
7686 if (*p == ',')
7687 ++p;
7688 }
7689 else if (event_name2nr(p, &p) == NUM_EVENTS)
7690 return FAIL;
7691 }
7692
7693 return OK;
7694 }
7695
7696 # if defined(FEAT_SYN_HL) || defined(PROTO)
7697
7698 /*
7699 * Add "what" to 'eventignore' to skip loading syntax highlighting for every
7700 * buffer loaded into the window. "what" must start with a comma.
7701 * Returns the old value of 'eventignore' in allocated memory.
7702 */
7703 char_u *
7704 au_event_disable(what)
7705 char *what;
7706 {
7707 char_u *new_ei;
7708 char_u *save_ei;
7709
7710 save_ei = vim_strsave(p_ei);
7711 if (save_ei != NULL)
7712 {
7713 new_ei = vim_strnsave(p_ei, (int)(STRLEN(p_ei) + STRLEN(what)));
7714 if (new_ei != NULL)
7715 {
7716 STRCAT(new_ei, what);
7717 set_string_option_direct((char_u *)"ei", -1, new_ei,
7718 OPT_FREE, SID_NONE);
7719 vim_free(new_ei);
7720 }
7721 }
7722 return save_ei;
7723 }
7724
7725 void
7726 au_event_restore(old_ei)
7727 char_u *old_ei;
7728 {
7729 if (old_ei != NULL)
7730 {
7731 set_string_option_direct((char_u *)"ei", -1, old_ei,
7732 OPT_FREE, SID_NONE);
7733 vim_free(old_ei);
7734 }
7735 }
7736 # endif /* FEAT_SYN_HL */
7737
7738 /*
7739 * do_autocmd() -- implements the :autocmd command. Can be used in the
7740 * following ways:
7741 *
7742 * :autocmd <event> <pat> <cmd> Add <cmd> to the list of commands that
7743 * will be automatically executed for <event>
7744 * when editing a file matching <pat>, in
7745 * the current group.
7746 * :autocmd <event> <pat> Show the auto-commands associated with
7747 * <event> and <pat>.
7748 * :autocmd <event> Show the auto-commands associated with
7749 * <event>.
7750 * :autocmd Show all auto-commands.
7751 * :autocmd! <event> <pat> <cmd> Remove all auto-commands associated with
7752 * <event> and <pat>, and add the command
7753 * <cmd>, for the current group.
7754 * :autocmd! <event> <pat> Remove all auto-commands associated with
7755 * <event> and <pat> for the current group.
7756 * :autocmd! <event> Remove all auto-commands associated with
7757 * <event> for the current group.
7758 * :autocmd! Remove ALL auto-commands for the current
7759 * group.
7760 *
7761 * Multiple events and patterns may be given separated by commas. Here are
7762 * some examples:
7763 * :autocmd bufread,bufenter *.c,*.h set tw=0 smartindent noic
7764 * :autocmd bufleave * set tw=79 nosmartindent ic infercase
7765 *
7766 * :autocmd * *.c show all autocommands for *.c files.
7767 *
7768 * Mostly a {group} argument can optionally appear before <event>.
7769 */
7770 void
7771 do_autocmd(arg, forceit)
7772 char_u *arg;
7773 int forceit;
7774 {
7775 char_u *pat;
7776 char_u *envpat = NULL;
7777 char_u *cmd;
7778 event_T event;
7779 int need_free = FALSE;
7780 int nested = FALSE;
7781 int group;
7782
7783 /*
7784 * Check for a legal group name. If not, use AUGROUP_ALL.
7785 */
7786 group = au_get_grouparg(&arg);
7787 if (arg == NULL) /* out of memory */
7788 return;
7789
7790 /*
7791 * Scan over the events.
7792 * If we find an illegal name, return here, don't do anything.
7793 */
7794 pat = find_end_event(arg, group != AUGROUP_ALL);
7795 if (pat == NULL)
7796 return;
7797
7798 /*
7799 * Scan over the pattern. Put a NUL at the end.
7800 */
7801 pat = skipwhite(pat);
7802 cmd = pat;
7803 while (*cmd && (!vim_iswhite(*cmd) || cmd[-1] == '\\'))
7804 cmd++;
7805 if (*cmd)
7806 *cmd++ = NUL;
7807
7808 /* Expand environment variables in the pattern. Set 'shellslash', we want
7809 * forward slashes here. */
7810 if (vim_strchr(pat, '$') != NULL || vim_strchr(pat, '~') != NULL)
7811 {
7812 #ifdef BACKSLASH_IN_FILENAME
7813 int p_ssl_save = p_ssl;
7814
7815 p_ssl = TRUE;
7816 #endif
7817 envpat = expand_env_save(pat);
7818 #ifdef BACKSLASH_IN_FILENAME
7819 p_ssl = p_ssl_save;
7820 #endif
7821 if (envpat != NULL)
7822 pat = envpat;
7823 }
7824
7825 /*
7826 * Check for "nested" flag.
7827 */
7828 cmd = skipwhite(cmd);
7829 if (*cmd != NUL && STRNCMP(cmd, "nested", 6) == 0 && vim_iswhite(cmd[6]))
7830 {
7831 nested = TRUE;
7832 cmd = skipwhite(cmd + 6);
7833 }
7834
7835 /*
7836 * Find the start of the commands.
7837 * Expand <sfile> in it.
7838 */
7839 if (*cmd != NUL)
7840 {
7841 cmd = expand_sfile(cmd);
7842 if (cmd == NULL) /* some error */
7843 return;
7844 need_free = TRUE;
7845 }
7846
7847 /*
7848 * Print header when showing autocommands.
7849 */
7850 if (!forceit && *cmd == NUL)
7851 {
7852 /* Highlight title */
7853 MSG_PUTS_TITLE(_("\n--- Auto-Commands ---"));
7854 }
7855
7856 /*
7857 * Loop over the events.
7858 */
7859 last_event = (event_T)-1; /* for listing the event name */
7860 last_group = AUGROUP_ERROR; /* for listing the group name */
7861 if (*arg == '*' || *arg == NUL)
7862 {
7863 for (event = (event_T)0; (int)event < (int)NUM_EVENTS;
7864 event = (event_T)((int)event + 1))
7865 if (do_autocmd_event(event, pat,
7866 nested, cmd, forceit, group) == FAIL)
7867 break;
7868 }
7869 else
7870 {
7871 while (*arg && !vim_iswhite(*arg))
7872 if (do_autocmd_event(event_name2nr(arg, &arg), pat,
7873 nested, cmd, forceit, group) == FAIL)
7874 break;
7875 }
7876
7877 if (need_free)
7878 vim_free(cmd);
7879 vim_free(envpat);
7880 }
7881
7882 /*
7883 * Find the group ID in a ":autocmd" or ":doautocmd" argument.
7884 * The "argp" argument is advanced to the following argument.
7885 *
7886 * Returns the group ID, AUGROUP_ERROR for error (out of memory).
7887 */
7888 static int
7889 au_get_grouparg(argp)
7890 char_u **argp;
7891 {
7892 char_u *group_name;
7893 char_u *p;
7894 char_u *arg = *argp;
7895 int group = AUGROUP_ALL;
7896
7897 p = skiptowhite(arg);
7898 if (p > arg)
7899 {
7900 group_name = vim_strnsave(arg, (int)(p - arg));
7901 if (group_name == NULL) /* out of memory */
7902 return AUGROUP_ERROR;
7903 group = au_find_group(group_name);
7904 if (group == AUGROUP_ERROR)
7905 group = AUGROUP_ALL; /* no match, use all groups */
7906 else
7907 *argp = skipwhite(p); /* match, skip over group name */
7908 vim_free(group_name);
7909 }
7910 return group;
7911 }
7912
7913 /*
7914 * do_autocmd() for one event.
7915 * If *pat == NUL do for all patterns.
7916 * If *cmd == NUL show entries.
7917 * If forceit == TRUE delete entries.
7918 * If group is not AUGROUP_ALL, only use this group.
7919 */
7920 static int
7921 do_autocmd_event(event, pat, nested, cmd, forceit, group)
7922 event_T event;
7923 char_u *pat;
7924 int nested;
7925 char_u *cmd;
7926 int forceit;
7927 int group;
7928 {
7929 AutoPat *ap;
7930 AutoPat **prev_ap;
7931 AutoCmd *ac;
7932 AutoCmd **prev_ac;
7933 int brace_level;
7934 char_u *endpat;
7935 int findgroup;
7936 int allgroups;
7937 int patlen;
7938 int is_buflocal;
7939 int buflocal_nr;
7940 char_u buflocal_pat[25]; /* for "<buffer=X>" */
7941
7942 if (group == AUGROUP_ALL)
7943 findgroup = current_augroup;
7944 else
7945 findgroup = group;
7946 allgroups = (group == AUGROUP_ALL && !forceit && *cmd == NUL);
7947
7948 /*
7949 * Show or delete all patterns for an event.
7950 */
7951 if (*pat == NUL)
7952 {
7953 for (ap = first_autopat[(int)event]; ap != NULL; ap = ap->next)
7954 {
7955 if (forceit) /* delete the AutoPat, if it's in the current group */
7956 {
7957 if (ap->group == findgroup)
7958 au_remove_pat(ap);
7959 }
7960 else if (group == AUGROUP_ALL || ap->group == group)
7961 show_autocmd(ap, event);
7962 }
7963 }
7964
7965 /*
7966 * Loop through all the specified patterns.
7967 */
7968 for ( ; *pat; pat = (*endpat == ',' ? endpat + 1 : endpat))
7969 {
7970 /*
7971 * Find end of the pattern.
7972 * Watch out for a comma in braces, like "*.\{obj,o\}".
7973 */
7974 brace_level = 0;
7975 for (endpat = pat; *endpat && (*endpat != ',' || brace_level
7976 || endpat[-1] == '\\'); ++endpat)
7977 {
7978 if (*endpat == '{')
7979 brace_level++;
7980 else if (*endpat == '}')
7981 brace_level--;
7982 }
7983 if (pat == endpat) /* ignore single comma */
7984 continue;
7985 patlen = (int)(endpat - pat);
7986
7987 /*
7988 * detect special <buflocal[=X]> buffer-local patterns
7989 */
7990 is_buflocal = FALSE;
7991 buflocal_nr = 0;
7992
7993 if (patlen >= 7 && STRNCMP(pat, "<buffer", 7) == 0
7994 && pat[patlen - 1] == '>')
7995 {
7996 /* Error will be printed only for addition. printing and removing
7997 * will proceed silently. */
7998 is_buflocal = TRUE;
7999 if (patlen == 8)
8000 buflocal_nr = curbuf->b_fnum;
8001 else if (patlen > 9 && pat[7] == '=')
8002 {
8003 /* <buffer=abuf> */
8004 if (patlen == 13 && STRNICMP(pat, "<buffer=abuf>", 13))
8005 buflocal_nr = autocmd_bufnr;
8006 /* <buffer=123> */
8007 else if (skipdigits(pat + 8) == pat + patlen - 1)
8008 buflocal_nr = atoi((char *)pat + 8);
8009 }
8010 }
8011
8012 if (is_buflocal)
8013 {
8014 /* normalize pat into standard "<buffer>#N" form */
8015 sprintf((char *)buflocal_pat, "<buffer=%d>", buflocal_nr);
8016 pat = buflocal_pat; /* can modify pat and patlen */
8017 patlen = (int)STRLEN(buflocal_pat); /* but not endpat */
8018 }
8019
8020 /*
8021 * Find AutoPat entries with this pattern.
8022 */
8023 prev_ap = &first_autopat[(int)event];
8024 while ((ap = *prev_ap) != NULL)
8025 {
8026 if (ap->pat != NULL)
8027 {
8028 /* Accept a pattern when:
8029 * - a group was specified and it's that group, or a group was
8030 * not specified and it's the current group, or a group was
8031 * not specified and we are listing
8032 * - the length of the pattern matches
8033 * - the pattern matches.
8034 * For <buffer[=X]>, this condition works because we normalize
8035 * all buffer-local patterns.
8036 */
8037 if ((allgroups || ap->group == findgroup)
8038 && ap->patlen == patlen
8039 && STRNCMP(pat, ap->pat, patlen) == 0)
8040 {
8041 /*
8042 * Remove existing autocommands.
8043 * If adding any new autocmd's for this AutoPat, don't
8044 * delete the pattern from the autopat list, append to
8045 * this list.
8046 */
8047 if (forceit)
8048 {
8049 if (*cmd != NUL && ap->next == NULL)
8050 {
8051 au_remove_cmds(ap);
8052 break;
8053 }
8054 au_remove_pat(ap);
8055 }
8056
8057 /*
8058 * Show autocmd's for this autopat, or buflocals <buffer=X>
8059 */
8060 else if (*cmd == NUL)
8061 show_autocmd(ap, event);
8062
8063 /*
8064 * Add autocmd to this autopat, if it's the last one.
8065 */
8066 else if (ap->next == NULL)
8067 break;
8068 }
8069 }
8070 prev_ap = &ap->next;
8071 }
8072
8073 /*
8074 * Add a new command.
8075 */
8076 if (*cmd != NUL)
8077 {
8078 /*
8079 * If the pattern we want to add a command to does appear at the
8080 * end of the list (or not is not in the list at all), add the
8081 * pattern at the end of the list.
8082 */
8083 if (ap == NULL)
8084 {
8085 /* refuse to add buffer-local ap if buffer number is invalid */
8086 if (is_buflocal && (buflocal_nr == 0
8087 || buflist_findnr(buflocal_nr) == NULL))
8088 {
8089 EMSGN(_("E680: <buffer=%d>: invalid buffer number "),
8090 buflocal_nr);
8091 return FAIL;
8092 }
8093
8094 ap = (AutoPat *)alloc((unsigned)sizeof(AutoPat));
8095 if (ap == NULL)
8096 return FAIL;
8097 ap->pat = vim_strnsave(pat, patlen);
8098 ap->patlen = patlen;
8099 if (ap->pat == NULL)
8100 {
8101 vim_free(ap);
8102 return FAIL;
8103 }
8104
8105 if (is_buflocal)
8106 {
8107 ap->buflocal_nr = buflocal_nr;
8108 ap->reg_prog = NULL;
8109 }
8110 else
8111 {
8112 char_u *reg_pat;
8113
8114 ap->buflocal_nr = 0;
8115 reg_pat = file_pat_to_reg_pat(pat, endpat,
8116 &ap->allow_dirs, TRUE);
8117 if (reg_pat != NULL)
8118 ap->reg_prog = vim_regcomp(reg_pat, RE_MAGIC);
8119 vim_free(reg_pat);
8120 if (reg_pat == NULL || ap->reg_prog == NULL)
8121 {
8122 vim_free(ap->pat);
8123 vim_free(ap);
8124 return FAIL;
8125 }
8126 }
8127 ap->cmds = NULL;
8128 *prev_ap = ap;
8129 ap->next = NULL;
8130 if (group == AUGROUP_ALL)
8131 ap->group = current_augroup;
8132 else
8133 ap->group = group;
8134 }
8135
8136 /*
8137 * Add the autocmd at the end of the AutoCmd list.
8138 */
8139 prev_ac = &(ap->cmds);
8140 while ((ac = *prev_ac) != NULL)
8141 prev_ac = &ac->next;
8142 ac = (AutoCmd *)alloc((unsigned)sizeof(AutoCmd));
8143 if (ac == NULL)
8144 return FAIL;
8145 ac->cmd = vim_strsave(cmd);
8146 #ifdef FEAT_EVAL
8147 ac->scriptID = current_SID;
8148 #endif
8149 if (ac->cmd == NULL)
8150 {
8151 vim_free(ac);
8152 return FAIL;
8153 }
8154 ac->next = NULL;
8155 *prev_ac = ac;
8156 ac->nested = nested;
8157 }
8158 }
8159
8160 au_cleanup(); /* may really delete removed patterns/commands now */
8161 return OK;
8162 }
8163
8164 /*
8165 * Implementation of ":doautocmd [group] event [fname]".
8166 * Return OK for success, FAIL for failure;
8167 */
8168 int
8169 do_doautocmd(arg, do_msg)
8170 char_u *arg;
8171 int do_msg; /* give message for no matching autocmds? */
8172 {
8173 char_u *fname;
8174 int nothing_done = TRUE;
8175 int group;
8176
8177 /*
8178 * Check for a legal group name. If not, use AUGROUP_ALL.
8179 */
8180 group = au_get_grouparg(&arg);
8181 if (arg == NULL) /* out of memory */
8182 return FAIL;
8183
8184 if (*arg == '*')
8185 {
8186 EMSG(_("E217: Can't execute autocommands for ALL events"));
8187 return FAIL;
8188 }
8189
8190 /*
8191 * Scan over the events.
8192 * If we find an illegal name, return here, don't do anything.
8193 */
8194 fname = find_end_event(arg, group != AUGROUP_ALL);
8195 if (fname == NULL)
8196 return FAIL;
8197
8198 fname = skipwhite(fname);
8199
8200 /*
8201 * Loop over the events.
8202 */
8203 while (*arg && !vim_iswhite(*arg))
8204 if (apply_autocmds_group(event_name2nr(arg, &arg),
8205 fname, NULL, TRUE, group, curbuf, NULL))
8206 nothing_done = FALSE;
8207
8208 if (nothing_done && do_msg)
8209 MSG(_("No matching autocommands"));
8210
8211 #ifdef FEAT_EVAL
8212 return aborting() ? FAIL : OK;
8213 #else
8214 return OK;
8215 #endif
8216 }
8217
8218 /*
8219 * ":doautoall": execute autocommands for each loaded buffer.
8220 */
8221 void
8222 ex_doautoall(eap)
8223 exarg_T *eap;
8224 {
8225 int retval;
8226 aco_save_T aco;
8227 buf_T *buf;
8228
8229 /*
8230 * This is a bit tricky: For some commands curwin->w_buffer needs to be
8231 * equal to curbuf, but for some buffers there may not be a window.
8232 * So we change the buffer for the current window for a moment. This
8233 * gives problems when the autocommands make changes to the list of
8234 * buffers or windows...
8235 */
8236 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
8237 {
8238 if (buf->b_ml.ml_mfp != NULL)
8239 {
8240 /* find a window for this buffer and save some values */
8241 aucmd_prepbuf(&aco, buf);
8242
8243 /* execute the autocommands for this buffer */
8244 retval = do_doautocmd(eap->arg, FALSE);
8245
8246 /* Execute the modeline settings, but don't set window-local
8247 * options if we are using the current window for another buffer. */
8248 do_modelines(aco.save_curwin == NULL ? OPT_NOWIN : 0);
8249
8250 /* restore the current window */
8251 aucmd_restbuf(&aco);
8252
8253 /* stop if there is some error or buffer was deleted */
8254 if (retval == FAIL || !buf_valid(buf))
8255 break;
8256 }
8257 }
8258
8259 check_cursor(); /* just in case lines got deleted */
8260 }
8261
8262 /*
8263 * Prepare for executing autocommands for (hidden) buffer "buf".
8264 * Search a window for the current buffer. Save the cursor position and
8265 * screen offset.
8266 * Set "curbuf" and "curwin" to match "buf".
8267 * When FEAT_AUTOCMD is not defined another version is used, see below.
8268 */
8269 void
8270 aucmd_prepbuf(aco, buf)
8271 aco_save_T *aco; /* structure to save values in */
8272 buf_T *buf; /* new curbuf */
8273 {
8274 win_T *win;
8275
8276 aco->new_curbuf = buf;
8277
8278 /* Find a window that is for the new buffer */
8279 if (buf == curbuf) /* be quick when buf is curbuf */
8280 win = curwin;
8281 else
8282 #ifdef FEAT_WINDOWS
8283 for (win = firstwin; win != NULL; win = win->w_next)
8284 if (win->w_buffer == buf)
8285 break;
8286 #else
8287 win = NULL;
8288 #endif
8289
8290 /*
8291 * Prefer to use an existing window for the buffer, it has the least side
8292 * effects (esp. if "buf" is curbuf).
8293 * Otherwise, use curwin for "buf". It might make some items in the
8294 * window invalid. At least save the cursor and topline.
8295 */
8296 if (win != NULL)
8297 {
8298 /* there is a window for "buf", make it the curwin */
8299 aco->save_curwin = curwin;
8300 curwin = win;
8301 aco->save_buf = win->w_buffer;
8302 aco->new_curwin = win;
8303 }
8304 else
8305 {
8306 /* there is no window for "buf", use curwin */
8307 aco->save_curwin = NULL;
8308 aco->save_buf = curbuf;
8309 --curbuf->b_nwindows;
8310 curwin->w_buffer = buf;
8311 ++buf->b_nwindows;
8312
8313 /* save cursor and topline, set them to safe values */
8314 aco->save_cursor = curwin->w_cursor;
8315 curwin->w_cursor.lnum = 1;
8316 curwin->w_cursor.col = 0;
8317 aco->save_topline = curwin->w_topline;
8318 curwin->w_topline = 1;
8319 #ifdef FEAT_DIFF
8320 aco->save_topfill = curwin->w_topfill;
8321 curwin->w_topfill = 0;
8322 #endif
8323 }
8324
8325 curbuf = buf;
8326 }
8327
8328 /*
8329 * Cleanup after executing autocommands for a (hidden) buffer.
8330 * Restore the window as it was (if possible).
8331 * When FEAT_AUTOCMD is not defined another version is used, see below.
8332 */
8333 void
8334 aucmd_restbuf(aco)
8335 aco_save_T *aco; /* structure holding saved values */
8336 {
8337 if (aco->save_curwin != NULL)
8338 {
8339 /* restore curwin */
8340 #ifdef FEAT_WINDOWS
8341 if (win_valid(aco->save_curwin))
8342 #endif
8343 {
8344 /* restore the buffer which was previously edited by curwin, if
8345 * it's still the same window and it's valid */
8346 if (curwin == aco->new_curwin
8347 && buf_valid(aco->save_buf)
8348 && aco->save_buf->b_ml.ml_mfp != NULL)
8349 {
8350 --curbuf->b_nwindows;
8351 curbuf = aco->save_buf;
8352 curwin->w_buffer = curbuf;
8353 ++curbuf->b_nwindows;
8354 }
8355
8356 curwin = aco->save_curwin;
8357 curbuf = curwin->w_buffer;
8358 }
8359 }
8360 else
8361 {
8362 /* restore buffer for curwin if it still exists and is loaded */
8363 if (buf_valid(aco->save_buf) && aco->save_buf->b_ml.ml_mfp != NULL)
8364 {
8365 --curbuf->b_nwindows;
8366 curbuf = aco->save_buf;
8367 curwin->w_buffer = curbuf;
8368 ++curbuf->b_nwindows;
8369 curwin->w_cursor = aco->save_cursor;
8370 check_cursor();
8371 /* check topline < line_count, in case lines got deleted */
8372 if (aco->save_topline <= curbuf->b_ml.ml_line_count)
8373 {
8374 curwin->w_topline = aco->save_topline;
8375 #ifdef FEAT_DIFF
8376 curwin->w_topfill = aco->save_topfill;
8377 #endif
8378 }
8379 else
8380 {
8381 curwin->w_topline = curbuf->b_ml.ml_line_count;
8382 #ifdef FEAT_DIFF
8383 curwin->w_topfill = 0;
8384 #endif
8385 }
8386 }
8387 }
8388 }
8389
8390 static int autocmd_nested = FALSE;
8391
8392 /*
8393 * Execute autocommands for "event" and file name "fname".
8394 * Return TRUE if some commands were executed.
8395 */
8396 int
8397 apply_autocmds(event, fname, fname_io, force, buf)
8398 event_T event;
8399 char_u *fname; /* NULL or empty means use actual file name */
8400 char_u *fname_io; /* fname to use for <afile> on cmdline */
8401 int force; /* when TRUE, ignore autocmd_busy */
8402 buf_T *buf; /* buffer for <abuf> */
8403 {
8404 return apply_autocmds_group(event, fname, fname_io, force,
8405 AUGROUP_ALL, buf, NULL);
8406 }
8407
8408 /*
8409 * Like apply_autocmds(), but with extra "eap" argument. This takes care of
8410 * setting v:filearg.
8411 */
8412 static int
8413 apply_autocmds_exarg(event, fname, fname_io, force, buf, eap)
8414 event_T event;
8415 char_u *fname;
8416 char_u *fname_io;
8417 int force;
8418 buf_T *buf;
8419 exarg_T *eap;
8420 {
8421 return apply_autocmds_group(event, fname, fname_io, force,
8422 AUGROUP_ALL, buf, eap);
8423 }
8424
8425 /*
8426 * Like apply_autocmds(), but handles the caller's retval. If the script
8427 * processing is being aborted or if retval is FAIL when inside a try
8428 * conditional, no autocommands are executed. If otherwise the autocommands
8429 * cause the script to be aborted, retval is set to FAIL.
8430 */
8431 int
8432 apply_autocmds_retval(event, fname, fname_io, force, buf, retval)
8433 event_T event;
8434 char_u *fname; /* NULL or empty means use actual file name */
8435 char_u *fname_io; /* fname to use for <afile> on cmdline */
8436 int force; /* when TRUE, ignore autocmd_busy */
8437 buf_T *buf; /* buffer for <abuf> */
8438 int *retval; /* pointer to caller's retval */
8439 {
8440 int did_cmd;
8441
8442 #ifdef FEAT_EVAL
8443 if (should_abort(*retval))
8444 return FALSE;
8445 #endif
8446
8447 did_cmd = apply_autocmds_group(event, fname, fname_io, force,
8448 AUGROUP_ALL, buf, NULL);
8449 if (did_cmd
8450 #ifdef FEAT_EVAL
8451 && aborting()
8452 #endif
8453 )
8454 *retval = FAIL;
8455 return did_cmd;
8456 }
8457
8458 /*
8459 * Return TRUE when there is a CursorHold autocommand defined.
8460 */
8461 int
8462 has_cursorhold()
8463 {
8464 return (first_autopat[(int)(get_real_state() == NORMAL_BUSY
8465 ? EVENT_CURSORHOLD : EVENT_CURSORHOLDI)] != NULL);
8466 }
8467
8468 /*
8469 * Return TRUE if the CursorHold event can be triggered.
8470 */
8471 int
8472 trigger_cursorhold()
8473 {
8474 int state;
8475
8476 /* trigger a compile request if the current buffer is in
8477 * the watchlist and the current mode is NOT CMDLINE. */
8478 if ((State & CMDLINE) == 0)
8479 if (cc_is_buf_watched(curbuf))
8480 cc_request_compile(curbuf);
8481
8482 if (!did_cursorhold && has_cursorhold() && !Recording
8483 #ifdef FEAT_INS_EXPAND
8484 && !ins_compl_active()
8485 #endif
8486 )
8487 {
8488 state = get_real_state();
8489 if (state == NORMAL_BUSY || (state & INSERT) != 0)
8490 return TRUE;
8491 }
8492 return FALSE;
8493 }
8494
8495 /*
8496 * Return TRUE when there is a CursorMoved autocommand defined.
8497 */
8498 int
8499 has_cursormoved()
8500 {
8501 return (first_autopat[(int)EVENT_CURSORMOVED] != NULL);
8502 }
8503
8504 /*
8505 * Return TRUE when there is a CursorMovedI autocommand defined.
8506 */
8507 int
8508 has_cursormovedI()
8509 {
8510 return (first_autopat[(int)EVENT_CURSORMOVEDI] != NULL);
8511 }
8512
8513 static int
8514 apply_autocmds_group(event, fname, fname_io, force, group, buf, eap)
8515 event_T event;
8516 char_u *fname; /* NULL or empty means use actual file name */
8517 char_u *fname_io; /* fname to use for <afile> on cmdline, NULL means
8518 use fname */
8519 int force; /* when TRUE, ignore autocmd_busy */
8520 int group; /* group ID, or AUGROUP_ALL */
8521 buf_T *buf; /* buffer for <abuf> */
8522 exarg_T *eap; /* command arguments */
8523 {
8524 char_u *sfname = NULL; /* short file name */
8525 char_u *tail;
8526 int save_changed;
8527 buf_T *old_curbuf;
8528 int retval = FALSE;
8529 char_u *save_sourcing_name;
8530 linenr_T save_sourcing_lnum;
8531 char_u *save_autocmd_fname;
8532 int save_autocmd_fname_full;
8533 int save_autocmd_bufnr;
8534 char_u *save_autocmd_match;
8535 int save_autocmd_busy;
8536 int save_autocmd_nested;
8537 static int nesting = 0;
8538 AutoPatCmd patcmd;
8539 AutoPat *ap;
8540 #ifdef FEAT_EVAL
8541 scid_T save_current_SID;
8542 void *save_funccalp;
8543 char_u *save_cmdarg;
8544 long save_cmdbang;
8545 #endif
8546 static int filechangeshell_busy = FALSE;
8547 #ifdef FEAT_PROFILE
8548 proftime_T wait_time;
8549 #endif
8550
8551 /*
8552 * Quickly return if there are no autocommands for this event or
8553 * autocommands are blocked.
8554 */
8555 if (first_autopat[(int)event] == NULL || autocmd_blocked > 0)
8556 goto BYPASS_AU;
8557
8558 /*
8559 * When autocommands are busy, new autocommands are only executed when
8560 * explicitly enabled with the "nested" flag.
8561 */
8562 if (autocmd_busy && !(force || autocmd_nested))
8563 goto BYPASS_AU;
8564
8565 #ifdef FEAT_EVAL
8566 /*
8567 * Quickly return when immediately aborting on error, or when an interrupt
8568 * occurred or an exception was thrown but not caught.
8569 */
8570 if (aborting())
8571 goto BYPASS_AU;
8572 #endif
8573
8574 /*
8575 * FileChangedShell never nests, because it can create an endless loop.
8576 */
8577 if (filechangeshell_busy && (event == EVENT_FILECHANGEDSHELL
8578 || event == EVENT_FILECHANGEDSHELLPOST))
8579 goto BYPASS_AU;
8580
8581 /*
8582 * Ignore events in 'eventignore'.
8583 */
8584 if (event_ignored(event))
8585 goto BYPASS_AU;
8586
8587 /*
8588 * Allow nesting of autocommands, but restrict the depth, because it's
8589 * possible to create an endless loop.
8590 */
8591 if (nesting == 10)
8592 {
8593 EMSG(_("E218: autocommand nesting too deep"));
8594 goto BYPASS_AU;
8595 }
8596
8597 /*
8598 * Check if these autocommands are disabled. Used when doing ":all" or
8599 * ":ball".
8600 */
8601 if ( (autocmd_no_enter
8602 && (event == EVENT_WINENTER || event == EVENT_BUFENTER))
8603 || (autocmd_no_leave
8604 && (event == EVENT_WINLEAVE || event == EVENT_BUFLEAVE)))
8605 goto BYPASS_AU;
8606
8607 /*
8608 * Save the autocmd_* variables and info about the current buffer.
8609 */
8610 save_autocmd_fname = autocmd_fname;
8611 save_autocmd_fname_full = autocmd_fname_full;
8612 save_autocmd_bufnr = autocmd_bufnr;
8613 save_autocmd_match = autocmd_match;
8614 save_autocmd_busy = autocmd_busy;
8615 save_autocmd_nested = autocmd_nested;
8616 save_changed = curbuf->b_changed;
8617 old_curbuf = curbuf;
8618
8619 /*
8620 * Set the file name to be used for <afile>.
8621 * Make a copy to avoid that changing a buffer name or directory makes it
8622 * invalid.
8623 */
8624 if (fname_io == NULL)
8625 {
8626 if (fname != NULL && *fname != NUL)
8627 autocmd_fname = fname;
8628 else if (buf != NULL)
8629 autocmd_fname = buf->b_ffname;
8630 else
8631 autocmd_fname = NULL;
8632 }
8633 else
8634 autocmd_fname = fname_io;
8635 if (autocmd_fname != NULL)
8636 autocmd_fname = vim_strsave(autocmd_fname);
8637 autocmd_fname_full = FALSE; /* call FullName_save() later */
8638
8639 /*
8640 * Set the buffer number to be used for <abuf>.
8641 */
8642 if (buf == NULL)
8643 autocmd_bufnr = 0;
8644 else
8645 autocmd_bufnr = buf->b_fnum;
8646
8647 /*
8648 * When the file name is NULL or empty, use the file name of buffer "buf".
8649 * Always use the full path of the file name to match with, in case
8650 * "allow_dirs" is set.
8651 */
8652 if (fname == NULL || *fname == NUL)
8653 {
8654 if (buf == NULL)
8655 fname = NULL;
8656 else
8657 {
8658 #ifdef FEAT_SYN_HL
8659 if (event == EVENT_SYNTAX)
8660 fname = buf->b_p_syn;
8661 else
8662 #endif
8663 if (event == EVENT_FILETYPE)
8664 fname = buf->b_p_ft;
8665 else
8666 {
8667 if (buf->b_sfname != NULL)
8668 sfname = vim_strsave(buf->b_sfname);
8669 fname = buf->b_ffname;
8670 }
8671 }
8672 if (fname == NULL)
8673 fname = (char_u *)"";
8674 fname = vim_strsave(fname); /* make a copy, so we can change it */
8675 }
8676 else
8677 {
8678 sfname = vim_strsave(fname);
8679 /* Don't try expanding FileType, Syntax, WindowID or QuickFixCmd* */
8680 if (event == EVENT_FILETYPE
8681 || event == EVENT_SYNTAX
8682 || event == EVENT_REMOTEREPLY
8683 || event == EVENT_SPELLFILEMISSING
8684 || event == EVENT_QUICKFIXCMDPRE
8685 || event == EVENT_QUICKFIXCMDPOST)
8686 fname = vim_strsave(fname);
8687 else
8688 fname = FullName_save(fname, FALSE);
8689 }
8690 if (fname == NULL) /* out of memory */
8691 {
8692 vim_free(sfname);
8693 retval = FALSE;
8694 goto BYPASS_AU;
8695 }
8696
8697 #ifdef BACKSLASH_IN_FILENAME
8698 /*
8699 * Replace all backslashes with forward slashes. This makes the
8700 * autocommand patterns portable between Unix and MS-DOS.
8701 */
8702 if (sfname != NULL)
8703 forward_slash(sfname);
8704 forward_slash(fname);
8705 #endif
8706
8707 #ifdef VMS
8708 /* remove version for correct match */
8709 if (sfname != NULL)
8710 vms_remove_version(sfname);
8711 vms_remove_version(fname);
8712 #endif
8713
8714 /*
8715 * Set the name to be used for <amatch>.
8716 */
8717 autocmd_match = fname;
8718
8719
8720 /* Don't redraw while doing auto commands. */
8721 ++RedrawingDisabled;
8722 save_sourcing_name = sourcing_name;
8723 sourcing_name = NULL; /* don't free this one */
8724 save_sourcing_lnum = sourcing_lnum;
8725 sourcing_lnum = 0; /* no line number here */
8726
8727 #ifdef FEAT_EVAL
8728 save_current_SID = current_SID;
8729
8730 # ifdef FEAT_PROFILE
8731 if (do_profiling == PROF_YES)
8732 prof_child_enter(&wait_time); /* doesn't count for the caller itself */
8733 # endif
8734
8735 /* Don't use local function variables, if called from a function */
8736 save_funccalp = save_funccal();
8737 #endif
8738
8739 /*
8740 * When starting to execute autocommands, save the search patterns.
8741 */
8742 if (!autocmd_busy)
8743 {
8744 save_search_patterns();
8745 saveRedobuff();
8746 did_filetype = keep_filetype;
8747 }
8748
8749 /*
8750 * Note that we are applying autocmds. Some commands need to know.
8751 */
8752 autocmd_busy = TRUE;
8753 filechangeshell_busy = (event == EVENT_FILECHANGEDSHELL);
8754 ++nesting; /* see matching decrement below */
8755
8756 /* Remember that FileType was triggered. Used for did_filetype(). */
8757 if (event == EVENT_FILETYPE)
8758 did_filetype = TRUE;
8759
8760 tail = gettail(fname);
8761
8762 /* Find first autocommand that matches */
8763 patcmd.curpat = first_autopat[(int)event];
8764 patcmd.nextcmd = NULL;
8765 patcmd.group = group;
8766 patcmd.fname = fname;
8767 patcmd.sfname = sfname;
8768 patcmd.tail = tail;
8769 patcmd.event = event;
8770 patcmd.arg_bufnr = autocmd_bufnr;
8771 patcmd.next = NULL;
8772 auto_next_pat(&patcmd, FALSE);
8773
8774 /* found one, start executing the autocommands */
8775 if (patcmd.curpat != NULL)
8776 {
8777 /* add to active_apc_list */
8778 patcmd.next = active_apc_list;
8779 active_apc_list = &patcmd;
8780
8781 #ifdef FEAT_EVAL
8782 /* set v:cmdarg (only when there is a matching pattern) */
8783 save_cmdbang = get_vim_var_nr(VV_CMDBANG);
8784 if (eap != NULL)
8785 {
8786 save_cmdarg = set_cmdarg(eap, NULL);
8787 set_vim_var_nr(VV_CMDBANG, (long)eap->forceit);
8788 }
8789 else
8790 save_cmdarg = NULL; /* avoid gcc warning */
8791 #endif
8792 retval = TRUE;
8793 /* mark the last pattern, to avoid an endless loop when more patterns
8794 * are added when executing autocommands */
8795 for (ap = patcmd.curpat; ap->next != NULL; ap = ap->next)
8796 ap->last = FALSE;
8797 ap->last = TRUE;
8798 check_lnums(TRUE); /* make sure cursor and topline are valid */
8799 do_cmdline(NULL, getnextac, (void *)&patcmd,
8800 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT);
8801 #ifdef FEAT_EVAL
8802 if (eap != NULL)
8803 {
8804 (void)set_cmdarg(NULL, save_cmdarg);
8805 set_vim_var_nr(VV_CMDBANG, save_cmdbang);
8806 }
8807 #endif
8808 /* delete from active_apc_list */
8809 if (active_apc_list == &patcmd) /* just in case */
8810 active_apc_list = patcmd.next;
8811 }
8812
8813 --RedrawingDisabled;
8814 autocmd_busy = save_autocmd_busy;
8815 filechangeshell_busy = FALSE;
8816 autocmd_nested = save_autocmd_nested;
8817 vim_free(sourcing_name);
8818 sourcing_name = save_sourcing_name;
8819 sourcing_lnum = save_sourcing_lnum;
8820 vim_free(autocmd_fname);
8821 autocmd_fname = save_autocmd_fname;
8822 autocmd_fname_full = save_autocmd_fname_full;
8823 autocmd_bufnr = save_autocmd_bufnr;
8824 autocmd_match = save_autocmd_match;
8825 #ifdef FEAT_EVAL
8826 current_SID = save_current_SID;
8827 restore_funccal(save_funccalp);
8828 # ifdef FEAT_PROFILE
8829 if (do_profiling == PROF_YES)
8830 prof_child_exit(&wait_time);
8831 # endif
8832 #endif
8833 vim_free(fname);
8834 vim_free(sfname);
8835 --nesting; /* see matching increment above */
8836
8837 /*
8838 * When stopping to execute autocommands, restore the search patterns and
8839 * the redo buffer.
8840 */
8841 if (!autocmd_busy)
8842 {
8843 restore_search_patterns();
8844 restoreRedobuff();
8845 did_filetype = FALSE;
8846 }
8847
8848 /*
8849 * Some events don't set or reset the Changed flag.
8850 * Check if still in the same buffer!
8851 */
8852 if (curbuf == old_curbuf
8853 && (event == EVENT_BUFREADPOST
8854 || event == EVENT_BUFWRITEPOST
8855 || event == EVENT_FILEAPPENDPOST
8856 || event == EVENT_VIMLEAVE
8857 || event == EVENT_VIMLEAVEPRE))
8858 {
8859 #ifdef FEAT_TITLE
8860 if (curbuf->b_changed != save_changed)
8861 need_maketitle = TRUE;
8862 #endif
8863 curbuf->b_changed = save_changed;
8864 }
8865
8866 au_cleanup(); /* may really delete removed patterns/commands now */
8867
8868 BYPASS_AU:
8869 /* When wiping out a buffer make sure all its buffer-local autocommands
8870 * are deleted. */
8871 if (event == EVENT_BUFWIPEOUT && buf != NULL)
8872 aubuflocal_remove(buf);
8873
8874 return retval;
8875 }
8876
8877 # ifdef FEAT_EVAL
8878 static char_u *old_termresponse = NULL;
8879 # endif
8880
8881 /*
8882 * Block triggering autocommands until unblock_autocmd() is called.
8883 * Can be used recursively, so long as it's symmetric.
8884 */
8885 void
8886 block_autocmds()
8887 {
8888 # ifdef FEAT_EVAL
8889 /* Remember the value of v:termresponse. */
8890 if (autocmd_blocked == 0)
8891 old_termresponse = get_vim_var_str(VV_TERMRESPONSE);
8892 # endif
8893 ++autocmd_blocked;
8894 }
8895
8896 void
8897 unblock_autocmds()
8898 {
8899 --autocmd_blocked;
8900
8901 # ifdef FEAT_EVAL
8902 /* When v:termresponse was set while autocommands were blocked, trigger
8903 * the autocommands now. Esp. useful when executing a shell command
8904 * during startup (vimdiff). */
8905 if (autocmd_blocked == 0
8906 && get_vim_var_str(VV_TERMRESPONSE) != old_termresponse)
8907 apply_autocmds(EVENT_TERMRESPONSE, NULL, NULL, FALSE, curbuf);
8908 # endif
8909 }
8910
8911 /*
8912 * Find next autocommand pattern that matches.
8913 */
8914 static void
8915 auto_next_pat(apc, stop_at_last)
8916 AutoPatCmd *apc;
8917 int stop_at_last; /* stop when 'last' flag is set */
8918 {
8919 AutoPat *ap;
8920 AutoCmd *cp;
8921 char_u *name;
8922 char *s;
8923
8924 vim_free(sourcing_name);
8925 sourcing_name = NULL;
8926
8927 for (ap = apc->curpat; ap != NULL && !got_int; ap = ap->next)
8928 {
8929 apc->curpat = NULL;
8930
8931 /* Only use a pattern when it has not been removed, has commands and
8932 * the group matches. For buffer-local autocommands only check the
8933 * buffer number. */
8934 if (ap->pat != NULL && ap->cmds != NULL
8935 && (apc->group == AUGROUP_ALL || apc->group == ap->group))
8936 {
8937 /* execution-condition */
8938 if (ap->buflocal_nr == 0
8939 ? (match_file_pat(NULL, ap->reg_prog, apc->fname,
8940 apc->sfname, apc->tail, ap->allow_dirs))
8941 : ap->buflocal_nr == apc->arg_bufnr)
8942 {
8943 name = event_nr2name(apc->event);
8944 s = _("%s Auto commands for \"%s\"");
8945 sourcing_name = alloc((unsigned)(STRLEN(s)
8946 + STRLEN(name) + ap->patlen + 1));
8947 if (sourcing_name != NULL)
8948 {
8949 sprintf((char *)sourcing_name, s,
8950 (char *)name, (char *)ap->pat);
8951 if (p_verbose >= 8)
8952 {
8953 verbose_enter();
8954 smsg((char_u *)_("Executing %s"), sourcing_name);
8955 verbose_leave();
8956 }
8957 }
8958
8959 apc->curpat = ap;
8960 apc->nextcmd = ap->cmds;
8961 /* mark last command */
8962 for (cp = ap->cmds; cp->next != NULL; cp = cp->next)
8963 cp->last = FALSE;
8964 cp->last = TRUE;
8965 }
8966 line_breakcheck();
8967 if (apc->curpat != NULL) /* found a match */
8968 break;
8969 }
8970 if (stop_at_last && ap->last)
8971 break;
8972 }
8973 }
8974
8975 /*
8976 * Get next autocommand command.
8977 * Called by do_cmdline() to get the next line for ":if".
8978 * Returns allocated string, or NULL for end of autocommands.
8979 */
8980 /* ARGSUSED */
8981 static char_u *
8982 getnextac(c, cookie, indent)
8983 int c; /* not used */
8984 void *cookie;
8985 int indent; /* not used */
8986 {
8987 AutoPatCmd *acp = (AutoPatCmd *)cookie;
8988 char_u *retval;
8989 AutoCmd *ac;
8990
8991 /* Can be called again after returning the last line. */
8992 if (acp->curpat == NULL)
8993 return NULL;
8994
8995 /* repeat until we find an autocommand to execute */
8996 for (;;)
8997 {
8998 /* skip removed commands */
8999 while (acp->nextcmd != NULL && acp->nextcmd->cmd == NULL)
9000 if (acp->nextcmd->last)
9001 acp->nextcmd = NULL;
9002 else
9003 acp->nextcmd = acp->nextcmd->next;
9004
9005 if (acp->nextcmd != NULL)
9006 break;
9007
9008 /* at end of commands, find next pattern that matches */
9009 if (acp->curpat->last)
9010 acp->curpat = NULL;
9011 else
9012 acp->curpat = acp->curpat->next;
9013 if (acp->curpat != NULL)
9014 auto_next_pat(acp, TRUE);
9015 if (acp->curpat == NULL)
9016 return NULL;
9017 }
9018
9019 ac = acp->nextcmd;
9020
9021 if (p_verbose >= 9)
9022 {
9023 verbose_enter_scroll();
9024 smsg((char_u *)_("autocommand %s"), ac->cmd);
9025 msg_puts((char_u *)"\n"); /* don't overwrite this either */
9026 verbose_leave_scroll();
9027 }
9028 retval = vim_strsave(ac->cmd);
9029 autocmd_nested = ac->nested;
9030 #ifdef FEAT_EVAL
9031 current_SID = ac->scriptID;
9032 #endif
9033 if (ac->last)
9034 acp->nextcmd = NULL;
9035 else
9036 acp->nextcmd = ac->next;
9037 return retval;
9038 }
9039
9040 /*
9041 * Return TRUE if there is a matching autocommand for "fname".
9042 * To account for buffer-local autocommands, function needs to know
9043 * in which buffer the file will be opened.
9044 */
9045 int
9046 has_autocmd(event, sfname, buf)
9047 event_T event;
9048 char_u *sfname;
9049 buf_T *buf;
9050 {
9051 AutoPat *ap;
9052 char_u *fname;
9053 char_u *tail = gettail(sfname);
9054 int retval = FALSE;
9055
9056 fname = FullName_save(sfname, FALSE);
9057 if (fname == NULL)
9058 return FALSE;
9059
9060 #ifdef BACKSLASH_IN_FILENAME
9061 /*
9062 * Replace all backslashes with forward slashes. This makes the
9063 * autocommand patterns portable between Unix and MS-DOS.
9064 */
9065 sfname = vim_strsave(sfname);
9066 if (sfname != NULL)
9067 forward_slash(sfname);
9068 forward_slash(fname);
9069 #endif
9070
9071 for (ap = first_autopat[(int)event]; ap != NULL; ap = ap->next)
9072 if (ap->pat != NULL && ap->cmds != NULL
9073 && (ap->buflocal_nr == 0
9074 ? match_file_pat(NULL, ap->reg_prog,
9075 fname, sfname, tail, ap->allow_dirs)
9076 : buf != NULL && ap->buflocal_nr == buf->b_fnum
9077 ))
9078 {
9079 retval = TRUE;
9080 break;
9081 }
9082
9083 vim_free(fname);
9084 #ifdef BACKSLASH_IN_FILENAME
9085 vim_free(sfname);
9086 #endif
9087
9088 return retval;
9089 }
9090
9091 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
9092 /*
9093 * Function given to ExpandGeneric() to obtain the list of autocommand group
9094 * names.
9095 */
9096 /*ARGSUSED*/
9097 char_u *
9098 get_augroup_name(xp, idx)
9099 expand_T *xp;
9100 int idx;
9101 {
9102 if (idx == augroups.ga_len) /* add "END" add the end */
9103 return (char_u *)"END";
9104 if (idx >= augroups.ga_len) /* end of list */
9105 return NULL;
9106 if (AUGROUP_NAME(idx) == NULL) /* skip deleted entries */
9107 return (char_u *)"";
9108 return AUGROUP_NAME(idx); /* return a name */
9109 }
9110
9111 static int include_groups = FALSE;
9112
9113 char_u *
9114 set_context_in_autocmd(xp, arg, doautocmd)
9115 expand_T *xp;
9116 char_u *arg;
9117 int doautocmd; /* TRUE for :doautocmd, FALSE for :autocmd */
9118 {
9119 char_u *p;
9120 int group;
9121
9122 /* check for a group name, skip it if present */
9123 include_groups = FALSE;
9124 p = arg;
9125 group = au_get_grouparg(&arg);
9126 if (group == AUGROUP_ERROR)
9127 return NULL;
9128 /* If there only is a group name that's what we expand. */
9129 if (*arg == NUL && group != AUGROUP_ALL && !vim_iswhite(arg[-1]))
9130 {
9131 arg = p;
9132 group = AUGROUP_ALL;
9133 }
9134
9135 /* skip over event name */
9136 for (p = arg; *p != NUL && !vim_iswhite(*p); ++p)
9137 if (*p == ',')
9138 arg = p + 1;
9139 if (*p == NUL)
9140 {
9141 if (group == AUGROUP_ALL)
9142 include_groups = TRUE;
9143 xp->xp_context = EXPAND_EVENTS; /* expand event name */
9144 xp->xp_pattern = arg;
9145 return NULL;
9146 }
9147
9148 /* skip over pattern */
9149 arg = skipwhite(p);
9150 while (*arg && (!vim_iswhite(*arg) || arg[-1] == '\\'))
9151 arg++;
9152 if (*arg)
9153 return arg; /* expand (next) command */
9154
9155 if (doautocmd)
9156 xp->xp_context = EXPAND_FILES; /* expand file names */
9157 else
9158 xp->xp_context = EXPAND_NOTHING; /* pattern is not expanded */
9159 return NULL;
9160 }
9161
9162 /*
9163 * Function given to ExpandGeneric() to obtain the list of event names.
9164 */
9165 /*ARGSUSED*/
9166 char_u *
9167 get_event_name(xp, idx)
9168 expand_T *xp;
9169 int idx;
9170 {
9171 if (idx < augroups.ga_len) /* First list group names, if wanted */
9172 {
9173 if (!include_groups || AUGROUP_NAME(idx) == NULL)
9174 return (char_u *)""; /* skip deleted entries */
9175 return AUGROUP_NAME(idx); /* return a name */
9176 }
9177 return (char_u *)event_names[idx - augroups.ga_len].name;
9178 }
9179
9180 #endif /* FEAT_CMDL_COMPL */
9181
9182 /*
9183 * Return TRUE if autocmd is supported.
9184 */
9185 int
9186 autocmd_supported(name)
9187 char_u *name;
9188 {
9189 char_u *p;
9190
9191 return (event_name2nr(name, &p) != NUM_EVENTS);
9192 }
9193
9194 /*
9195 * Return TRUE if an autocommand is defined for a group, event and
9196 * pattern: The group can be omitted to accept any group. "event" and "pattern"
9197 * can be NULL to accept any event and pattern. "pattern" can be NULL to accept
9198 * any pattern. Buffer-local patterns <buffer> or <buffer=N> are accepted.
9199 * Used for:
9200 * exists("#Group") or
9201 * exists("#Group#Event") or
9202 * exists("#Group#Event#pat") or
9203 * exists("#Event") or
9204 * exists("#Event#pat")
9205 */
9206 int
9207 au_exists(arg)
9208 char_u *arg;
9209 {
9210 char_u *arg_save;
9211 char_u *pattern = NULL;
9212 char_u *event_name;
9213 char_u *p;
9214 event_T event;
9215 AutoPat *ap;
9216 buf_T *buflocal_buf = NULL;
9217 int group;
9218 int retval = FALSE;
9219
9220 /* Make a copy so that we can change the '#' chars to a NUL. */
9221 arg_save = vim_strsave(arg);
9222 if (arg_save == NULL)
9223 return FALSE;
9224 p = vim_strchr(arg_save, '#');
9225 if (p != NULL)
9226 *p++ = NUL;
9227
9228 /* First, look for an autocmd group name */
9229 group = au_find_group(arg_save);
9230 if (group == AUGROUP_ERROR)
9231 {
9232 /* Didn't match a group name, assume the first argument is an event. */
9233 group = AUGROUP_ALL;
9234 event_name = arg_save;
9235 }
9236 else
9237 {
9238 if (p == NULL)
9239 {
9240 /* "Group": group name is present and it's recognized */
9241 retval = TRUE;
9242 goto theend;
9243 }
9244
9245 /* Must be "Group#Event" or "Group#Event#pat". */
9246 event_name = p;
9247 p = vim_strchr(event_name, '#');
9248 if (p != NULL)
9249 *p++ = NUL; /* "Group#Event#pat" */
9250 }
9251
9252 pattern = p; /* "pattern" is NULL when there is no pattern */
9253
9254 /* find the index (enum) for the event name */
9255 event = event_name2nr(event_name, &p);
9256
9257 /* return FALSE if the event name is not recognized */
9258 if (event == NUM_EVENTS)
9259 goto theend;
9260
9261 /* Find the first autocommand for this event.
9262 * If there isn't any, return FALSE;
9263 * If there is one and no pattern given, return TRUE; */
9264 ap = first_autopat[(int)event];
9265 if (ap == NULL)
9266 goto theend;
9267 if (pattern == NULL)
9268 {
9269 retval = TRUE;
9270 goto theend;
9271 }
9272
9273 /* if pattern is "<buffer>", special handling is needed which uses curbuf */
9274 /* for pattern "<buffer=N>, fnamecmp() will work fine */
9275 if (STRICMP(pattern, "<buffer>") == 0)
9276 buflocal_buf = curbuf;
9277
9278 /* Check if there is an autocommand with the given pattern. */
9279 for ( ; ap != NULL; ap = ap->next)
9280 /* only use a pattern when it has not been removed and has commands. */
9281 /* For buffer-local autocommands, fnamecmp() works fine. */
9282 if (ap->pat != NULL && ap->cmds != NULL
9283 && (group == AUGROUP_ALL || ap->group == group)
9284 && (buflocal_buf == NULL
9285 ? fnamecmp(ap->pat, pattern) == 0
9286 : ap->buflocal_nr == buflocal_buf->b_fnum))
9287 {
9288 retval = TRUE;
9289 break;
9290 }
9291
9292 theend:
9293 vim_free(arg_save);
9294 return retval;
9295 }
9296
9297 #else /* FEAT_AUTOCMD */
9298
9299 /*
9300 * Prepare for executing commands for (hidden) buffer "buf".
9301 * This is the non-autocommand version, it simply saves "curbuf" and sets
9302 * "curbuf" and "curwin" to match "buf".
9303 */
9304 void
9305 aucmd_prepbuf(aco, buf)
9306 aco_save_T *aco; /* structure to save values in */
9307 buf_T *buf; /* new curbuf */
9308 {
9309 aco->save_buf = curbuf;
9310 curbuf = buf;
9311 curwin->w_buffer = buf;
9312 }
9313
9314 /*
9315 * Restore after executing commands for a (hidden) buffer.
9316 * This is the non-autocommand version.
9317 */
9318 void
9319 aucmd_restbuf(aco)
9320 aco_save_T *aco; /* structure holding saved values */
9321 {
9322 curbuf = aco->save_buf;
9323 curwin->w_buffer = curbuf;
9324 }
9325
9326 #endif /* FEAT_AUTOCMD */
9327
9328
9329 #if defined(FEAT_AUTOCMD) || defined(FEAT_WILDIGN) || defined(PROTO)
9330 /*
9331 * Try matching a filename with a "pattern" ("prog" is NULL), or use the
9332 * precompiled regprog "prog" ("pattern" is NULL). That avoids calling
9333 * vim_regcomp() often.
9334 * Used for autocommands and 'wildignore'.
9335 * Returns TRUE if there is a match, FALSE otherwise.
9336 */
9337 int
9338 match_file_pat(pattern, prog, fname, sfname, tail, allow_dirs)
9339 char_u *pattern; /* pattern to match with */
9340 regprog_T *prog; /* pre-compiled regprog or NULL */
9341 char_u *fname; /* full path of file name */
9342 char_u *sfname; /* short file name or NULL */
9343 char_u *tail; /* tail of path */
9344 int allow_dirs; /* allow matching with dir */
9345 {
9346 regmatch_T regmatch;
9347 int result = FALSE;
9348 #ifdef FEAT_OSFILETYPE
9349 int no_pattern = FALSE; /* TRUE if check is filetype only */
9350 char_u *type_start;
9351 char_u c;
9352 int match = FALSE;
9353 #endif
9354
9355 #ifdef CASE_INSENSITIVE_FILENAME
9356 regmatch.rm_ic = TRUE; /* Always ignore case */
9357 #else
9358 regmatch.rm_ic = FALSE; /* Don't ever ignore case */
9359 #endif
9360 #ifdef FEAT_OSFILETYPE
9361 if (*pattern == '<')
9362 {
9363 /* There is a filetype condition specified with this pattern.
9364 * Check the filetype matches first. If not, don't bother with the
9365 * pattern (set regprog to NULL).
9366 * Always use magic for the regexp.
9367 */
9368
9369 for (type_start = pattern + 1; (c = *pattern); pattern++)
9370 {
9371 if ((c == ';' || c == '>') && match == FALSE)
9372 {
9373 *pattern = NUL; /* Terminate the string */
9374 match = mch_check_filetype(fname, type_start);
9375 *pattern = c; /* Restore the terminator */
9376 type_start = pattern + 1;
9377 }
9378 if (c == '>')
9379 break;
9380 }
9381
9382 /* (c should never be NUL, but check anyway) */
9383 if (match == FALSE || c == NUL)
9384 regmatch.regprog = NULL; /* Doesn't match - don't check pat. */
9385 else if (*pattern == NUL)
9386 {
9387 regmatch.regprog = NULL; /* Vim will try to free regprog later */
9388 no_pattern = TRUE; /* Always matches - don't check pat. */
9389 }
9390 else
9391 regmatch.regprog = vim_regcomp(pattern + 1, RE_MAGIC);
9392 }
9393 else
9394 #endif
9395 {
9396 if (prog != NULL)
9397 regmatch.regprog = prog;
9398 else
9399 regmatch.regprog = vim_regcomp(pattern, RE_MAGIC);
9400 }
9401
9402 /*
9403 * Try for a match with the pattern with:
9404 * 1. the full file name, when the pattern has a '/'.
9405 * 2. the short file name, when the pattern has a '/'.
9406 * 3. the tail of the file name, when the pattern has no '/'.
9407 */
9408 if (
9409 #ifdef FEAT_OSFILETYPE
9410 /* If the check is for a filetype only and we don't care
9411 * about the path then skip all the regexp stuff.
9412 */
9413 no_pattern ||
9414 #endif
9415 (regmatch.regprog != NULL
9416 && ((allow_dirs
9417 && (vim_regexec(&regmatch, fname, (colnr_T)0)
9418 || (sfname != NULL
9419 && vim_regexec(&regmatch, sfname, (colnr_T)0))))
9420 || (!allow_dirs && vim_regexec(&regmatch, tail, (colnr_T)0)))))
9421 result = TRUE;
9422
9423 if (prog == NULL)
9424 vim_free(regmatch.regprog);
9425 return result;
9426 }
9427 #endif
9428
9429 #if defined(FEAT_WILDIGN) || defined(PROTO)
9430 /*
9431 * Return TRUE if a file matches with a pattern in "list".
9432 * "list" is a comma-separated list of patterns, like 'wildignore'.
9433 * "sfname" is the short file name or NULL, "ffname" the long file name.
9434 */
9435 int
9436 match_file_list(list, sfname, ffname)
9437 char_u *list;
9438 char_u *sfname;
9439 char_u *ffname;
9440 {
9441 char_u buf[100];
9442 char_u *tail;
9443 char_u *regpat;
9444 char allow_dirs;
9445 int match;
9446 char_u *p;
9447
9448 tail = gettail(sfname);
9449
9450 /* try all patterns in 'wildignore' */
9451 p = list;
9452 while (*p)
9453 {
9454 copy_option_part(&p, buf, 100, ",");
9455 regpat = file_pat_to_reg_pat(buf, NULL, &allow_dirs, FALSE);
9456 if (regpat == NULL)
9457 break;
9458 match = match_file_pat(regpat, NULL, ffname, sfname,
9459 tail, (int)allow_dirs);
9460 vim_free(regpat);
9461 if (match)
9462 return TRUE;
9463 }
9464 return FALSE;
9465 }
9466 #endif
9467
9468 /*
9469 * Convert the given pattern "pat" which has shell style wildcards in it, into
9470 * a regular expression, and return the result in allocated memory. If there
9471 * is a directory path separator to be matched, then TRUE is put in
9472 * allow_dirs, otherwise FALSE is put there -- webb.
9473 * Handle backslashes before special characters, like "\*" and "\ ".
9474 *
9475 * If FEAT_OSFILETYPE defined then pass initial <type> through unchanged. Eg:
9476 * '<html>myfile' becomes '<html>^myfile$' -- leonard.
9477 *
9478 * Returns NULL when out of memory.
9479 */
9480 /*ARGSUSED*/
9481 char_u *
9482 file_pat_to_reg_pat(pat, pat_end, allow_dirs, no_bslash)
9483 char_u *pat;
9484 char_u *pat_end; /* first char after pattern or NULL */
9485 char *allow_dirs; /* Result passed back out in here */
9486 int no_bslash; /* Don't use a backward slash as pathsep */
9487 {
9488 int size;
9489 char_u *endp;
9490 char_u *reg_pat;
9491 char_u *p;
9492 int i;
9493 int nested = 0;
9494 int add_dollar = TRUE;
9495 #ifdef FEAT_OSFILETYPE
9496 int check_length = 0;
9497 #endif
9498
9499 if (allow_dirs != NULL)
9500 *allow_dirs = FALSE;
9501 if (pat_end == NULL)
9502 pat_end = pat + STRLEN(pat);
9503
9504 #ifdef FEAT_OSFILETYPE
9505 /* Find out how much of the string is the filetype check */
9506 if (*pat == '<')
9507 {
9508 /* Count chars until the next '>' */
9509 for (p = pat + 1; p < pat_end && *p != '>'; p++)
9510 ;
9511 if (p < pat_end)
9512 {
9513 /* Pattern is of the form <.*>.* */
9514 check_length = p - pat + 1;
9515 if (p + 1 >= pat_end)
9516 {
9517 /* The 'pattern' is a filetype check ONLY */
9518 reg_pat = (char_u *)alloc(check_length + 1);
9519 if (reg_pat != NULL)
9520 {
9521 mch_memmove(reg_pat, pat, (size_t)check_length);
9522 reg_pat[check_length] = NUL;
9523 }
9524 return reg_pat;
9525 }
9526 }
9527 /* else: there was no closing '>' - assume it was a normal pattern */
9528
9529 }
9530 pat += check_length;
9531 size = 2 + check_length;
9532 #else
9533 size = 2; /* '^' at start, '$' at end */
9534 #endif
9535
9536 for (p = pat; p < pat_end; p++)
9537 {
9538 switch (*p)
9539 {
9540 case '*':
9541 case '.':
9542 case ',':
9543 case '{':
9544 case '}':
9545 case '~':
9546 size += 2; /* extra backslash */
9547 break;
9548 #ifdef BACKSLASH_IN_FILENAME
9549 case '\\':
9550 case '/':
9551 size += 4; /* could become "[\/]" */
9552 break;
9553 #endif
9554 default:
9555 size++;
9556 # ifdef FEAT_MBYTE
9557 if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
9558 {
9559 ++p;
9560 ++size;
9561 }
9562 # endif
9563 break;
9564 }
9565 }
9566 reg_pat = alloc(size + 1);
9567 if (reg_pat == NULL)
9568 return NULL;
9569
9570 #ifdef FEAT_OSFILETYPE
9571 /* Copy the type check in to the start. */
9572 if (check_length)
9573 mch_memmove(reg_pat, pat - check_length, (size_t)check_length);
9574 i = check_length;
9575 #else
9576 i = 0;
9577 #endif
9578
9579 if (pat[0] == '*')
9580 while (pat[0] == '*' && pat < pat_end - 1)
9581 pat++;
9582 else
9583 reg_pat[i++] = '^';
9584 endp = pat_end - 1;
9585 if (*endp == '*')
9586 {
9587 while (endp - pat > 0 && *endp == '*')
9588 endp--;
9589 add_dollar = FALSE;
9590 }
9591 for (p = pat; *p && nested >= 0 && p <= endp; p++)
9592 {
9593 switch (*p)
9594 {
9595 case '*':
9596 reg_pat[i++] = '.';
9597 reg_pat[i++] = '*';
9598 while (p[1] == '*') /* "**" matches like "*" */
9599 ++p;
9600 break;
9601 case '.':
9602 #ifdef RISCOS
9603 if (allow_dirs != NULL)
9604 *allow_dirs = TRUE;
9605 /* FALLTHROUGH */
9606 #endif
9607 case '~':
9608 reg_pat[i++] = '\\';
9609 reg_pat[i++] = *p;
9610 break;
9611 case '?':
9612 #ifdef RISCOS
9613 case '#':
9614 #endif
9615 reg_pat[i++] = '.';
9616 break;
9617 case '\\':
9618 if (p[1] == NUL)
9619 break;
9620 #ifdef BACKSLASH_IN_FILENAME
9621 if (!no_bslash)
9622 {
9623 /* translate:
9624 * "\x" to "\\x" e.g., "dir\file"
9625 * "\*" to "\\.*" e.g., "dir\*.c"
9626 * "\?" to "\\." e.g., "dir\??.c"
9627 * "\+" to "\+" e.g., "fileX\+.c"
9628 */
9629 if ((vim_isfilec(p[1]) || p[1] == '*' || p[1] == '?')
9630 && p[1] != '+')
9631 {
9632 reg_pat[i++] = '[';
9633 reg_pat[i++] = '\\';
9634 reg_pat[i++] = '/';
9635 reg_pat[i++] = ']';
9636 if (allow_dirs != NULL)
9637 *allow_dirs = TRUE;
9638 break;
9639 }
9640 }
9641 #endif
9642 if (*++p == '?'
9643 #ifdef BACKSLASH_IN_FILENAME
9644 && no_bslash
9645 #endif
9646 )
9647 reg_pat[i++] = '?';
9648 else
9649 if (*p == ',')
9650 reg_pat[i++] = ',';
9651 else
9652 {
9653 if (allow_dirs != NULL && vim_ispathsep(*p)
9654 #ifdef BACKSLASH_IN_FILENAME
9655 && (!no_bslash || *p != '\\')
9656 #endif
9657 )
9658 *allow_dirs = TRUE;
9659 reg_pat[i++] = '\\';
9660 reg_pat[i++] = *p;
9661 }
9662 break;
9663 #ifdef BACKSLASH_IN_FILENAME
9664 case '/':
9665 reg_pat[i++] = '[';
9666 reg_pat[i++] = '\\';
9667 reg_pat[i++] = '/';
9668 reg_pat[i++] = ']';
9669 if (allow_dirs != NULL)
9670 *allow_dirs = TRUE;
9671 break;
9672 #endif
9673 case '{':
9674 reg_pat[i++] = '\\';
9675 reg_pat[i++] = '(';
9676 nested++;
9677 break;
9678 case '}':
9679 reg_pat[i++] = '\\';
9680 reg_pat[i++] = ')';
9681 --nested;
9682 break;
9683 case ',':
9684 if (nested)
9685 {
9686 reg_pat[i++] = '\\';
9687 reg_pat[i++] = '|';
9688 }
9689 else
9690 reg_pat[i++] = ',';
9691 break;
9692 default:
9693 # ifdef FEAT_MBYTE
9694 if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
9695 reg_pat[i++] = *p++;
9696 else
9697 # endif
9698 if (allow_dirs != NULL && vim_ispathsep(*p))
9699 *allow_dirs = TRUE;
9700 reg_pat[i++] = *p;
9701 break;
9702 }
9703 }
9704 if (add_dollar)
9705 reg_pat[i++] = '$';
9706 reg_pat[i] = NUL;
9707 if (nested != 0)
9708 {
9709 if (nested < 0)
9710 EMSG(_("E219: Missing {."));
9711 else
9712 EMSG(_("E220: Missing }."));
9713 vim_free(reg_pat);
9714 reg_pat = NULL;
9715 }
9716 return reg_pat;
9717 }
Vim with various extensions