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