Coerce MacVim to work with LCC
[MacVim.git] / src / fileio.c
blobc154fff85401746f0b44e8bf1d7b806f655e9365
1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
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 */
11 * fileio.c: read from and write to a file
14 #if defined(MSDOS) || defined(WIN16) || defined(WIN32) || defined(_WIN64)
15 # include "vimio.h" /* for lseek(), must be before vim.h */
16 #endif
18 #if defined __EMX__
19 # include "vimio.h" /* for mktemp(), CJW 1997-12-03 */
20 #endif
22 #include "vim.h"
24 #ifdef HAVE_FCNTL_H
25 # include <fcntl.h>
26 #endif
28 #ifdef __TANDEM
29 # include <limits.h> /* for SSIZE_MAX */
30 #endif
32 #if defined(HAVE_UTIME) && defined(HAVE_UTIME_H)
33 # include <utime.h> /* for struct utimbuf */
34 #endif
36 #define BUFSIZE 8192 /* size of normal write buffer */
37 #define SMBUFSIZE 256 /* size of emergency write buffer */
39 #ifdef FEAT_CRYPT
40 # define CRYPT_MAGIC "VimCrypt~01!" /* "01" is the version nr */
41 # define CRYPT_MAGIC_LEN 12 /* must be multiple of 4! */
42 #endif
44 /* Is there any system that doesn't have access()? */
45 #define USE_MCH_ACCESS
47 #if defined(sun) && defined(S_ISCHR)
48 # define OPEN_CHR_FILES
49 static int is_dev_fd_file(char_u *fname);
50 #endif
51 #ifdef FEAT_MBYTE
52 static char_u *next_fenc __ARGS((char_u **pp));
53 # ifdef FEAT_EVAL
54 static char_u *readfile_charconvert __ARGS((char_u *fname, char_u *fenc, int *fdp));
55 # endif
56 #endif
57 #ifdef FEAT_VIMINFO
58 static void check_marks_read __ARGS((void));
59 #endif
60 #ifdef FEAT_CRYPT
61 static char_u *check_for_cryptkey __ARGS((char_u *cryptkey, char_u *ptr, long *sizep, long *filesizep, int newfile));
62 #endif
63 #ifdef UNIX
64 static void set_file_time __ARGS((char_u *fname, time_t atime, time_t mtime));
65 #endif
66 static int set_rw_fname __ARGS((char_u *fname, char_u *sfname));
67 static int msg_add_fileformat __ARGS((int eol_type));
68 static void msg_add_eol __ARGS((void));
69 static int check_mtime __ARGS((buf_T *buf, struct stat *s));
70 static int time_differs __ARGS((long t1, long t2));
71 #ifdef FEAT_AUTOCMD
72 static int apply_autocmds_exarg __ARGS((event_T event, char_u *fname, char_u *fname_io, int force, buf_T *buf, exarg_T *eap));
73 static int au_find_group __ARGS((char_u *name));
75 # define AUGROUP_DEFAULT -1 /* default autocmd group */
76 # define AUGROUP_ERROR -2 /* errornouse autocmd group */
77 # define AUGROUP_ALL -3 /* all autocmd groups */
78 #endif
80 #if defined(FEAT_CRYPT) || defined(FEAT_MBYTE)
81 # define HAS_BW_FLAGS
82 # define FIO_LATIN1 0x01 /* convert Latin1 */
83 # define FIO_UTF8 0x02 /* convert UTF-8 */
84 # define FIO_UCS2 0x04 /* convert UCS-2 */
85 # define FIO_UCS4 0x08 /* convert UCS-4 */
86 # define FIO_UTF16 0x10 /* convert UTF-16 */
87 # ifdef WIN3264
88 # define FIO_CODEPAGE 0x20 /* convert MS-Windows codepage */
89 # define FIO_PUT_CP(x) (((x) & 0xffff) << 16) /* put codepage in top word */
90 # define FIO_GET_CP(x) (((x)>>16) & 0xffff) /* get codepage from top word */
91 # endif
92 # ifdef MACOS_X
93 # define FIO_MACROMAN 0x20 /* convert MacRoman */
94 # endif
95 # define FIO_ENDIAN_L 0x80 /* little endian */
96 # define FIO_ENCRYPTED 0x1000 /* encrypt written bytes */
97 # define FIO_NOCONVERT 0x2000 /* skip encoding conversion */
98 # define FIO_UCSBOM 0x4000 /* check for BOM at start of file */
99 # define FIO_ALL -1 /* allow all formats */
100 #endif
102 /* When converting, a read() or write() may leave some bytes to be converted
103 * for the next call. The value is guessed... */
104 #define CONV_RESTLEN 30
106 /* We have to guess how much a sequence of bytes may expand when converting
107 * with iconv() to be able to allocate a buffer. */
108 #define ICONV_MULT 8
111 * Structure to pass arguments from buf_write() to buf_write_bytes().
113 struct bw_info
115 int bw_fd; /* file descriptor */
116 char_u *bw_buf; /* buffer with data to be written */
117 int bw_len; /* length of data */
118 #ifdef HAS_BW_FLAGS
119 int bw_flags; /* FIO_ flags */
120 #endif
121 #ifdef FEAT_MBYTE
122 char_u bw_rest[CONV_RESTLEN]; /* not converted bytes */
123 int bw_restlen; /* nr of bytes in bw_rest[] */
124 int bw_first; /* first write call */
125 char_u *bw_conv_buf; /* buffer for writing converted chars */
126 int bw_conv_buflen; /* size of bw_conv_buf */
127 int bw_conv_error; /* set for conversion error */
128 # ifdef USE_ICONV
129 iconv_t bw_iconv_fd; /* descriptor for iconv() or -1 */
130 # endif
131 #endif
134 static int buf_write_bytes __ARGS((struct bw_info *ip));
136 #ifdef FEAT_MBYTE
137 static linenr_T readfile_linenr __ARGS((linenr_T linecnt, char_u *p, char_u *endp));
138 static int ucs2bytes __ARGS((unsigned c, char_u **pp, int flags));
139 static int same_encoding __ARGS((char_u *a, char_u *b));
140 static int get_fio_flags __ARGS((char_u *ptr));
141 static char_u *check_for_bom __ARGS((char_u *p, long size, int *lenp, int flags));
142 static int make_bom __ARGS((char_u *buf, char_u *name));
143 # ifdef WIN3264
144 static int get_win_fio_flags __ARGS((char_u *ptr));
145 # endif
146 # ifdef MACOS_X
147 static int get_mac_fio_flags __ARGS((char_u *ptr));
148 # endif
149 #endif
150 static int move_lines __ARGS((buf_T *frombuf, buf_T *tobuf));
153 void
154 filemess(buf, name, s, attr)
155 buf_T *buf;
156 char_u *name;
157 char_u *s;
158 int attr;
160 int msg_scroll_save;
162 if (msg_silent != 0)
163 return;
164 msg_add_fname(buf, name); /* put file name in IObuff with quotes */
165 /* If it's extremely long, truncate it. */
166 if (STRLEN(IObuff) > IOSIZE - 80)
167 IObuff[IOSIZE - 80] = NUL;
168 STRCAT(IObuff, s);
170 * For the first message may have to start a new line.
171 * For further ones overwrite the previous one, reset msg_scroll before
172 * calling filemess().
174 msg_scroll_save = msg_scroll;
175 if (shortmess(SHM_OVERALL) && !exiting && p_verbose == 0)
176 msg_scroll = FALSE;
177 if (!msg_scroll) /* wait a bit when overwriting an error msg */
178 check_for_delay(FALSE);
179 msg_start();
180 msg_scroll = msg_scroll_save;
181 msg_scrolled_ign = TRUE;
182 /* may truncate the message to avoid a hit-return prompt */
183 msg_outtrans_attr(msg_may_trunc(FALSE, IObuff), attr);
184 msg_clr_eos();
185 out_flush();
186 msg_scrolled_ign = FALSE;
190 * Read lines from file "fname" into the buffer after line "from".
192 * 1. We allocate blocks with lalloc, as big as possible.
193 * 2. Each block is filled with characters from the file with a single read().
194 * 3. The lines are inserted in the buffer with ml_append().
196 * (caller must check that fname != NULL, unless READ_STDIN is used)
198 * "lines_to_skip" is the number of lines that must be skipped
199 * "lines_to_read" is the number of lines that are appended
200 * When not recovering lines_to_skip is 0 and lines_to_read MAXLNUM.
202 * flags:
203 * READ_NEW starting to edit a new buffer
204 * READ_FILTER reading filter output
205 * READ_STDIN read from stdin instead of a file
206 * READ_BUFFER read from curbuf instead of a file (converting after reading
207 * stdin)
208 * READ_DUMMY read into a dummy buffer (to check if file contents changed)
210 * return FAIL for failure, OK otherwise
213 readfile(fname, sfname, from, lines_to_skip, lines_to_read, eap, flags)
214 char_u *fname;
215 char_u *sfname;
216 linenr_T from;
217 linenr_T lines_to_skip;
218 linenr_T lines_to_read;
219 exarg_T *eap; /* can be NULL! */
220 int flags;
222 int fd = 0;
223 int newfile = (flags & READ_NEW);
224 int check_readonly;
225 int filtering = (flags & READ_FILTER);
226 int read_stdin = (flags & READ_STDIN);
227 int read_buffer = (flags & READ_BUFFER);
228 int set_options = newfile || read_buffer
229 || (eap != NULL && eap->read_edit);
230 linenr_T read_buf_lnum = 1; /* next line to read from curbuf */
231 colnr_T read_buf_col = 0; /* next char to read from this line */
232 char_u c;
233 linenr_T lnum = from;
234 char_u *ptr = NULL; /* pointer into read buffer */
235 char_u *buffer = NULL; /* read buffer */
236 char_u *new_buffer = NULL; /* init to shut up gcc */
237 char_u *line_start = NULL; /* init to shut up gcc */
238 int wasempty; /* buffer was empty before reading */
239 colnr_T len;
240 long size = 0;
241 char_u *p;
242 long filesize = 0;
243 int skip_read = FALSE;
244 #ifdef FEAT_CRYPT
245 char_u *cryptkey = NULL;
246 #endif
247 int split = 0; /* number of split lines */
248 #define UNKNOWN 0x0fffffff /* file size is unknown */
249 linenr_T linecnt;
250 int error = FALSE; /* errors encountered */
251 int ff_error = EOL_UNKNOWN; /* file format with errors */
252 long linerest = 0; /* remaining chars in line */
253 #ifdef UNIX
254 int perm = 0;
255 int swap_mode = -1; /* protection bits for swap file */
256 #else
257 int perm;
258 #endif
259 int fileformat = 0; /* end-of-line format */
260 int keep_fileformat = FALSE;
261 struct stat st;
262 int file_readonly;
263 linenr_T skip_count = 0;
264 linenr_T read_count = 0;
265 int msg_save = msg_scroll;
266 linenr_T read_no_eol_lnum = 0; /* non-zero lnum when last line of
267 * last read was missing the eol */
268 int try_mac = (vim_strchr(p_ffs, 'm') != NULL);
269 int try_dos = (vim_strchr(p_ffs, 'd') != NULL);
270 int try_unix = (vim_strchr(p_ffs, 'x') != NULL);
271 int file_rewind = FALSE;
272 #ifdef FEAT_MBYTE
273 int can_retry;
274 linenr_T conv_error = 0; /* line nr with conversion error */
275 linenr_T illegal_byte = 0; /* line nr with illegal byte */
276 int keep_dest_enc = FALSE; /* don't retry when char doesn't fit
277 in destination encoding */
278 int bad_char_behavior = BAD_REPLACE;
279 /* BAD_KEEP, BAD_DROP or character to
280 * replace with */
281 char_u *tmpname = NULL; /* name of 'charconvert' output file */
282 int fio_flags = 0;
283 char_u *fenc; /* fileencoding to use */
284 int fenc_alloced; /* fenc_next is in allocated memory */
285 char_u *fenc_next = NULL; /* next item in 'fencs' or NULL */
286 int advance_fenc = FALSE;
287 long real_size = 0;
288 # ifdef USE_ICONV
289 iconv_t iconv_fd = (iconv_t)-1; /* descriptor for iconv() or -1 */
290 # ifdef FEAT_EVAL
291 int did_iconv = FALSE; /* TRUE when iconv() failed and trying
292 'charconvert' next */
293 # endif
294 # endif
295 int converted = FALSE; /* TRUE if conversion done */
296 int notconverted = FALSE; /* TRUE if conversion wanted but it
297 wasn't possible */
298 char_u conv_rest[CONV_RESTLEN];
299 int conv_restlen = 0; /* nr of bytes in conv_rest[] */
300 #endif
302 write_no_eol_lnum = 0; /* in case it was set by the previous read */
305 * If there is no file name yet, use the one for the read file.
306 * BF_NOTEDITED is set to reflect this.
307 * Don't do this for a read from a filter.
308 * Only do this when 'cpoptions' contains the 'f' flag.
310 if (curbuf->b_ffname == NULL
311 && !filtering
312 && fname != NULL
313 && vim_strchr(p_cpo, CPO_FNAMER) != NULL
314 && !(flags & READ_DUMMY))
316 if (set_rw_fname(fname, sfname) == FAIL)
317 return FAIL;
320 /* After reading a file the cursor line changes but we don't want to
321 * display the line. */
322 ex_no_reprint = TRUE;
324 /* don't display the file info for another buffer now */
325 need_fileinfo = FALSE;
328 * For Unix: Use the short file name whenever possible.
329 * Avoids problems with networks and when directory names are changed.
330 * Don't do this for MS-DOS, a "cd" in a sub-shell may have moved us to
331 * another directory, which we don't detect.
333 if (sfname == NULL)
334 sfname = fname;
335 #if defined(UNIX) || defined(__EMX__)
336 fname = sfname;
337 #endif
339 #ifdef FEAT_AUTOCMD
341 * The BufReadCmd and FileReadCmd events intercept the reading process by
342 * executing the associated commands instead.
344 if (!filtering && !read_stdin && !read_buffer)
346 pos_T pos;
348 pos = curbuf->b_op_start;
350 /* Set '[ mark to the line above where the lines go (line 1 if zero). */
351 curbuf->b_op_start.lnum = ((from == 0) ? 1 : from);
352 curbuf->b_op_start.col = 0;
354 if (newfile)
356 if (apply_autocmds_exarg(EVENT_BUFREADCMD, NULL, sfname,
357 FALSE, curbuf, eap))
358 #ifdef FEAT_EVAL
359 return aborting() ? FAIL : OK;
360 #else
361 return OK;
362 #endif
364 else if (apply_autocmds_exarg(EVENT_FILEREADCMD, sfname, sfname,
365 FALSE, NULL, eap))
366 #ifdef FEAT_EVAL
367 return aborting() ? FAIL : OK;
368 #else
369 return OK;
370 #endif
372 curbuf->b_op_start = pos;
374 #endif
376 if ((shortmess(SHM_OVER) || curbuf->b_help) && p_verbose == 0)
377 msg_scroll = FALSE; /* overwrite previous file message */
378 else
379 msg_scroll = TRUE; /* don't overwrite previous file message */
382 * If the name ends in a path separator, we can't open it. Check here,
383 * because reading the file may actually work, but then creating the swap
384 * file may destroy it! Reported on MS-DOS and Win 95.
385 * If the name is too long we might crash further on, quit here.
387 if (fname != NULL && *fname != NUL)
389 p = fname + STRLEN(fname);
390 if (after_pathsep(fname, p) || STRLEN(fname) >= MAXPATHL)
392 filemess(curbuf, fname, (char_u *)_("Illegal file name"), 0);
393 msg_end();
394 msg_scroll = msg_save;
395 return FAIL;
399 #ifdef UNIX
401 * On Unix it is possible to read a directory, so we have to
402 * check for it before the mch_open().
404 if (!read_stdin && !read_buffer)
406 perm = mch_getperm(fname);
407 if (perm >= 0 && !S_ISREG(perm) /* not a regular file ... */
408 # ifdef S_ISFIFO
409 && !S_ISFIFO(perm) /* ... or fifo */
410 # endif
411 # ifdef S_ISSOCK
412 && !S_ISSOCK(perm) /* ... or socket */
413 # endif
414 # ifdef OPEN_CHR_FILES
415 && !(S_ISCHR(perm) && is_dev_fd_file(fname))
416 /* ... or a character special file named /dev/fd/<n> */
417 # endif
420 if (S_ISDIR(perm))
421 filemess(curbuf, fname, (char_u *)_("is a directory"), 0);
422 else
423 filemess(curbuf, fname, (char_u *)_("is not a file"), 0);
424 msg_end();
425 msg_scroll = msg_save;
426 return FAIL;
429 # if defined(MSDOS) || defined(MSWIN) || defined(OS2)
431 * MS-Windows allows opening a device, but we will probably get stuck
432 * trying to read it.
434 if (!p_odev && mch_nodetype(fname) == NODE_WRITABLE)
436 filemess(curbuf, fname, (char_u *)_("is a device (disabled with 'opendevice' option)"), 0);
437 msg_end();
438 msg_scroll = msg_save;
439 return FAIL;
441 # endif
443 #endif
445 /* set default 'fileformat' */
446 if (set_options)
448 if (eap != NULL && eap->force_ff != 0)
449 set_fileformat(get_fileformat_force(curbuf, eap), OPT_LOCAL);
450 else if (*p_ffs != NUL)
451 set_fileformat(default_fileformat(), OPT_LOCAL);
454 /* set or reset 'binary' */
455 if (eap != NULL && eap->force_bin != 0)
457 int oldval = curbuf->b_p_bin;
459 curbuf->b_p_bin = (eap->force_bin == FORCE_BIN);
460 set_options_bin(oldval, curbuf->b_p_bin, OPT_LOCAL);
464 * When opening a new file we take the readonly flag from the file.
465 * Default is r/w, can be set to r/o below.
466 * Don't reset it when in readonly mode
467 * Only set/reset b_p_ro when BF_CHECK_RO is set.
469 check_readonly = (newfile && (curbuf->b_flags & BF_CHECK_RO));
470 if (check_readonly && !readonlymode)
471 curbuf->b_p_ro = FALSE;
473 if (newfile && !read_stdin && !read_buffer)
475 /* Remember time of file.
476 * For RISCOS, also remember the filetype.
478 if (mch_stat((char *)fname, &st) >= 0)
480 buf_store_time(curbuf, &st, fname);
481 curbuf->b_mtime_read = curbuf->b_mtime;
483 #if defined(RISCOS) && defined(FEAT_OSFILETYPE)
484 /* Read the filetype into the buffer local filetype option. */
485 mch_read_filetype(fname);
486 #endif
487 #ifdef UNIX
489 * Use the protection bits of the original file for the swap file.
490 * This makes it possible for others to read the name of the
491 * edited file from the swapfile, but only if they can read the
492 * edited file.
493 * Remove the "write" and "execute" bits for group and others
494 * (they must not write the swapfile).
495 * Add the "read" and "write" bits for the user, otherwise we may
496 * not be able to write to the file ourselves.
497 * Setting the bits is done below, after creating the swap file.
499 swap_mode = (st.st_mode & 0644) | 0600;
500 #endif
501 #ifdef FEAT_CW_EDITOR
502 /* Get the FSSpec on MacOS
503 * TODO: Update it properly when the buffer name changes
505 (void)GetFSSpecFromPath(curbuf->b_ffname, &curbuf->b_FSSpec);
506 #endif
507 #ifdef VMS
508 curbuf->b_fab_rfm = st.st_fab_rfm;
509 curbuf->b_fab_rat = st.st_fab_rat;
510 curbuf->b_fab_mrs = st.st_fab_mrs;
511 #endif
513 else
515 curbuf->b_mtime = 0;
516 curbuf->b_mtime_read = 0;
517 curbuf->b_orig_size = 0;
518 curbuf->b_orig_mode = 0;
521 /* Reset the "new file" flag. It will be set again below when the
522 * file doesn't exist. */
523 curbuf->b_flags &= ~(BF_NEW | BF_NEW_W);
527 * for UNIX: check readonly with perm and mch_access()
528 * for RISCOS: same as Unix, otherwise file gets re-datestamped!
529 * for MSDOS and Amiga: check readonly by trying to open the file for writing
531 file_readonly = FALSE;
532 if (read_stdin)
534 #if defined(MSDOS) || defined(MSWIN) || defined(OS2)
535 /* Force binary I/O on stdin to avoid CR-LF -> LF conversion. */
536 setmode(0, O_BINARY);
537 #endif
539 else if (!read_buffer)
541 #ifdef USE_MCH_ACCESS
542 if (
543 # ifdef UNIX
544 !(perm & 0222) ||
545 # endif
546 mch_access((char *)fname, W_OK))
547 file_readonly = TRUE;
548 fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
549 #else
550 if (!newfile
551 || readonlymode
552 || (fd = mch_open((char *)fname, O_RDWR | O_EXTRA, 0)) < 0)
554 file_readonly = TRUE;
555 /* try to open ro */
556 fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
558 #endif
561 if (fd < 0) /* cannot open at all */
563 #ifndef UNIX
564 int isdir_f;
565 #endif
566 msg_scroll = msg_save;
567 #ifndef UNIX
569 * On MSDOS and Amiga we can't open a directory, check here.
571 isdir_f = (mch_isdir(fname));
572 perm = mch_getperm(fname); /* check if the file exists */
573 if (isdir_f)
575 filemess(curbuf, sfname, (char_u *)_("is a directory"), 0);
576 curbuf->b_p_ro = TRUE; /* must use "w!" now */
578 else
579 #endif
580 if (newfile)
582 if (perm < 0)
585 * Set the 'new-file' flag, so that when the file has
586 * been created by someone else, a ":w" will complain.
588 curbuf->b_flags |= BF_NEW;
590 /* Create a swap file now, so that other Vims are warned
591 * that we are editing this file. Don't do this for a
592 * "nofile" or "nowrite" buffer type. */
593 #ifdef FEAT_QUICKFIX
594 if (!bt_dontwrite(curbuf))
595 #endif
596 check_need_swap(newfile);
597 if (dir_of_file_exists(fname))
598 filemess(curbuf, sfname, (char_u *)_("[New File]"), 0);
599 else
600 filemess(curbuf, sfname,
601 (char_u *)_("[New DIRECTORY]"), 0);
602 #ifdef FEAT_VIMINFO
603 /* Even though this is a new file, it might have been
604 * edited before and deleted. Get the old marks. */
605 check_marks_read();
606 #endif
607 #ifdef FEAT_MBYTE
608 if (eap != NULL && eap->force_enc != 0)
610 /* set forced 'fileencoding' */
611 fenc = enc_canonize(eap->cmd + eap->force_enc);
612 if (fenc != NULL)
613 set_string_option_direct((char_u *)"fenc", -1,
614 fenc, OPT_FREE|OPT_LOCAL, 0);
615 vim_free(fenc);
617 #endif
618 #ifdef FEAT_AUTOCMD
619 apply_autocmds_exarg(EVENT_BUFNEWFILE, sfname, sfname,
620 FALSE, curbuf, eap);
621 #endif
622 /* remember the current fileformat */
623 save_file_ff(curbuf);
625 #if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
626 if (aborting()) /* autocmds may abort script processing */
627 return FAIL;
628 #endif
629 return OK; /* a new file is not an error */
631 else
633 filemess(curbuf, sfname, (char_u *)(
634 # ifdef EFBIG
635 (errno == EFBIG) ? _("[File too big]") :
636 # endif
637 _("[Permission Denied]")), 0);
638 curbuf->b_p_ro = TRUE; /* must use "w!" now */
642 return FAIL;
646 * Only set the 'ro' flag for readonly files the first time they are
647 * loaded. Help files always get readonly mode
649 if ((check_readonly && file_readonly) || curbuf->b_help)
650 curbuf->b_p_ro = TRUE;
652 if (set_options)
654 /* Don't change 'eol' if reading from buffer as it will already be
655 * correctly set when reading stdin. */
656 if (!read_buffer)
658 curbuf->b_p_eol = TRUE;
659 curbuf->b_start_eol = TRUE;
661 #ifdef FEAT_MBYTE
662 curbuf->b_p_bomb = FALSE;
663 curbuf->b_start_bomb = FALSE;
664 #endif
667 /* Create a swap file now, so that other Vims are warned that we are
668 * editing this file.
669 * Don't do this for a "nofile" or "nowrite" buffer type. */
670 #ifdef FEAT_QUICKFIX
671 if (!bt_dontwrite(curbuf))
672 #endif
674 check_need_swap(newfile);
675 #ifdef UNIX
676 /* Set swap file protection bits after creating it. */
677 if (swap_mode > 0 && curbuf->b_ml.ml_mfp->mf_fname != NULL)
678 (void)mch_setperm(curbuf->b_ml.ml_mfp->mf_fname, (long)swap_mode);
679 #endif
682 #if defined(HAS_SWAP_EXISTS_ACTION)
683 /* If "Quit" selected at ATTENTION dialog, don't load the file */
684 if (swap_exists_action == SEA_QUIT)
686 if (!read_buffer && !read_stdin)
687 close(fd);
688 return FAIL;
690 #endif
692 ++no_wait_return; /* don't wait for return yet */
695 * Set '[ mark to the line above where the lines go (line 1 if zero).
697 curbuf->b_op_start.lnum = ((from == 0) ? 1 : from);
698 curbuf->b_op_start.col = 0;
700 #ifdef FEAT_AUTOCMD
701 if (!read_buffer)
703 int m = msg_scroll;
704 int n = msg_scrolled;
705 buf_T *old_curbuf = curbuf;
708 * The file must be closed again, the autocommands may want to change
709 * the file before reading it.
711 if (!read_stdin)
712 close(fd); /* ignore errors */
715 * The output from the autocommands should not overwrite anything and
716 * should not be overwritten: Set msg_scroll, restore its value if no
717 * output was done.
719 msg_scroll = TRUE;
720 if (filtering)
721 apply_autocmds_exarg(EVENT_FILTERREADPRE, NULL, sfname,
722 FALSE, curbuf, eap);
723 else if (read_stdin)
724 apply_autocmds_exarg(EVENT_STDINREADPRE, NULL, sfname,
725 FALSE, curbuf, eap);
726 else if (newfile)
727 apply_autocmds_exarg(EVENT_BUFREADPRE, NULL, sfname,
728 FALSE, curbuf, eap);
729 else
730 apply_autocmds_exarg(EVENT_FILEREADPRE, sfname, sfname,
731 FALSE, NULL, eap);
732 if (msg_scrolled == n)
733 msg_scroll = m;
735 #ifdef FEAT_EVAL
736 if (aborting()) /* autocmds may abort script processing */
738 --no_wait_return;
739 msg_scroll = msg_save;
740 curbuf->b_p_ro = TRUE; /* must use "w!" now */
741 return FAIL;
743 #endif
745 * Don't allow the autocommands to change the current buffer.
746 * Try to re-open the file.
748 if (!read_stdin && (curbuf != old_curbuf
749 || (fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0)) < 0))
751 --no_wait_return;
752 msg_scroll = msg_save;
753 if (fd < 0)
754 EMSG(_("E200: *ReadPre autocommands made the file unreadable"));
755 else
756 EMSG(_("E201: *ReadPre autocommands must not change current buffer"));
757 curbuf->b_p_ro = TRUE; /* must use "w!" now */
758 return FAIL;
761 #endif /* FEAT_AUTOCMD */
763 /* Autocommands may add lines to the file, need to check if it is empty */
764 wasempty = (curbuf->b_ml.ml_flags & ML_EMPTY);
766 if (!recoverymode && !filtering && !(flags & READ_DUMMY))
769 * Show the user that we are busy reading the input. Sometimes this
770 * may take a while. When reading from stdin another program may
771 * still be running, don't move the cursor to the last line, unless
772 * always using the GUI.
774 if (read_stdin)
776 #ifndef ALWAYS_USE_GUI
777 mch_msg(_("Vim: Reading from stdin...\n"));
778 #endif
779 #ifdef FEAT_GUI
780 /* Also write a message in the GUI window, if there is one. */
781 if (gui.in_use && !gui.dying && !gui.starting)
783 p = (char_u *)_("Reading from stdin...");
784 gui_write(p, (int)STRLEN(p));
786 #endif
788 else if (!read_buffer)
789 filemess(curbuf, sfname, (char_u *)"", 0);
792 msg_scroll = FALSE; /* overwrite the file message */
795 * Set linecnt now, before the "retry" caused by a wrong guess for
796 * fileformat, and after the autocommands, which may change them.
798 linecnt = curbuf->b_ml.ml_line_count;
800 #ifdef FEAT_MBYTE
801 /* "++bad=" argument. */
802 if (eap != NULL && eap->bad_char != 0)
804 bad_char_behavior = eap->bad_char;
805 if (set_options)
806 curbuf->b_bad_char = eap->bad_char;
808 else
809 curbuf->b_bad_char = 0;
812 * Decide which 'encoding' to use or use first.
814 if (eap != NULL && eap->force_enc != 0)
816 fenc = enc_canonize(eap->cmd + eap->force_enc);
817 fenc_alloced = TRUE;
818 keep_dest_enc = TRUE;
820 else if (curbuf->b_p_bin)
822 fenc = (char_u *)""; /* binary: don't convert */
823 fenc_alloced = FALSE;
825 else if (curbuf->b_help)
827 char_u firstline[80];
828 int fc;
830 /* Help files are either utf-8 or latin1. Try utf-8 first, if this
831 * fails it must be latin1.
832 * Always do this when 'encoding' is "utf-8". Otherwise only do
833 * this when needed to avoid [converted] remarks all the time.
834 * It is needed when the first line contains non-ASCII characters.
835 * That is only in *.??x files. */
836 fenc = (char_u *)"latin1";
837 c = enc_utf8;
838 if (!c && !read_stdin)
840 fc = fname[STRLEN(fname) - 1];
841 if (TOLOWER_ASC(fc) == 'x')
843 /* Read the first line (and a bit more). Immediately rewind to
844 * the start of the file. If the read() fails "len" is -1. */
845 len = vim_read(fd, firstline, 80);
846 lseek(fd, (off_t)0L, SEEK_SET);
847 for (p = firstline; p < firstline + len; ++p)
848 if (*p >= 0x80)
850 c = TRUE;
851 break;
856 if (c)
858 fenc_next = fenc;
859 fenc = (char_u *)"utf-8";
861 /* When the file is utf-8 but a character doesn't fit in
862 * 'encoding' don't retry. In help text editing utf-8 bytes
863 * doesn't make sense. */
864 if (!enc_utf8)
865 keep_dest_enc = TRUE;
867 fenc_alloced = FALSE;
869 else if (*p_fencs == NUL)
871 fenc = curbuf->b_p_fenc; /* use format from buffer */
872 fenc_alloced = FALSE;
874 else
876 fenc_next = p_fencs; /* try items in 'fileencodings' */
877 fenc = next_fenc(&fenc_next);
878 fenc_alloced = TRUE;
880 #endif
883 * Jump back here to retry reading the file in different ways.
884 * Reasons to retry:
885 * - encoding conversion failed: try another one from "fenc_next"
886 * - BOM detected and fenc was set, need to setup conversion
887 * - "fileformat" check failed: try another
889 * Variables set for special retry actions:
890 * "file_rewind" Rewind the file to start reading it again.
891 * "advance_fenc" Advance "fenc" using "fenc_next".
892 * "skip_read" Re-use already read bytes (BOM detected).
893 * "did_iconv" iconv() conversion failed, try 'charconvert'.
894 * "keep_fileformat" Don't reset "fileformat".
896 * Other status indicators:
897 * "tmpname" When != NULL did conversion with 'charconvert'.
898 * Output file has to be deleted afterwards.
899 * "iconv_fd" When != -1 did conversion with iconv().
901 retry:
903 if (file_rewind)
905 if (read_buffer)
907 read_buf_lnum = 1;
908 read_buf_col = 0;
910 else if (read_stdin || lseek(fd, (off_t)0L, SEEK_SET) != 0)
912 /* Can't rewind the file, give up. */
913 error = TRUE;
914 goto failed;
916 /* Delete the previously read lines. */
917 while (lnum > from)
918 ml_delete(lnum--, FALSE);
919 file_rewind = FALSE;
920 #ifdef FEAT_MBYTE
921 if (set_options)
923 curbuf->b_p_bomb = FALSE;
924 curbuf->b_start_bomb = FALSE;
926 conv_error = 0;
927 #endif
931 * When retrying with another "fenc" and the first time "fileformat"
932 * will be reset.
934 if (keep_fileformat)
935 keep_fileformat = FALSE;
936 else
938 if (eap != NULL && eap->force_ff != 0)
939 fileformat = get_fileformat_force(curbuf, eap);
940 else if (curbuf->b_p_bin)
941 fileformat = EOL_UNIX; /* binary: use Unix format */
942 else if (*p_ffs == NUL)
943 fileformat = get_fileformat(curbuf);/* use format from buffer */
944 else
945 fileformat = EOL_UNKNOWN; /* detect from file */
948 #ifdef FEAT_MBYTE
949 # ifdef USE_ICONV
950 if (iconv_fd != (iconv_t)-1)
952 /* aborted conversion with iconv(), close the descriptor */
953 iconv_close(iconv_fd);
954 iconv_fd = (iconv_t)-1;
956 # endif
958 if (advance_fenc)
961 * Try the next entry in 'fileencodings'.
963 advance_fenc = FALSE;
965 if (eap != NULL && eap->force_enc != 0)
967 /* Conversion given with "++cc=" wasn't possible, read
968 * without conversion. */
969 notconverted = TRUE;
970 conv_error = 0;
971 if (fenc_alloced)
972 vim_free(fenc);
973 fenc = (char_u *)"";
974 fenc_alloced = FALSE;
976 else
978 if (fenc_alloced)
979 vim_free(fenc);
980 if (fenc_next != NULL)
982 fenc = next_fenc(&fenc_next);
983 fenc_alloced = (fenc_next != NULL);
985 else
987 fenc = (char_u *)"";
988 fenc_alloced = FALSE;
991 if (tmpname != NULL)
993 mch_remove(tmpname); /* delete converted file */
994 vim_free(tmpname);
995 tmpname = NULL;
1000 * Conversion is required when the encoding of the file is different
1001 * from 'encoding' or 'encoding' is UTF-16, UCS-2 or UCS-4 (requires
1002 * conversion to UTF-8).
1004 fio_flags = 0;
1005 converted = (*fenc != NUL && !same_encoding(p_enc, fenc));
1006 if (converted || enc_unicode != 0)
1009 /* "ucs-bom" means we need to check the first bytes of the file
1010 * for a BOM. */
1011 if (STRCMP(fenc, ENC_UCSBOM) == 0)
1012 fio_flags = FIO_UCSBOM;
1015 * Check if UCS-2/4 or Latin1 to UTF-8 conversion needs to be
1016 * done. This is handled below after read(). Prepare the
1017 * fio_flags to avoid having to parse the string each time.
1018 * Also check for Unicode to Latin1 conversion, because iconv()
1019 * appears not to handle this correctly. This works just like
1020 * conversion to UTF-8 except how the resulting character is put in
1021 * the buffer.
1023 else if (enc_utf8 || STRCMP(p_enc, "latin1") == 0)
1024 fio_flags = get_fio_flags(fenc);
1026 # ifdef WIN3264
1028 * Conversion from an MS-Windows codepage to UTF-8 or another codepage
1029 * is handled with MultiByteToWideChar().
1031 if (fio_flags == 0)
1032 fio_flags = get_win_fio_flags(fenc);
1033 # endif
1035 # ifdef MACOS_X
1036 /* Conversion from Apple MacRoman to latin1 or UTF-8 */
1037 if (fio_flags == 0)
1038 fio_flags = get_mac_fio_flags(fenc);
1039 # endif
1041 # ifdef USE_ICONV
1043 * Try using iconv() if we can't convert internally.
1045 if (fio_flags == 0
1046 # ifdef FEAT_EVAL
1047 && !did_iconv
1048 # endif
1050 iconv_fd = (iconv_t)my_iconv_open(
1051 enc_utf8 ? (char_u *)"utf-8" : p_enc, fenc);
1052 # endif
1054 # ifdef FEAT_EVAL
1056 * Use the 'charconvert' expression when conversion is required
1057 * and we can't do it internally or with iconv().
1059 if (fio_flags == 0 && !read_stdin && !read_buffer && *p_ccv != NUL
1060 # ifdef USE_ICONV
1061 && iconv_fd == (iconv_t)-1
1062 # endif
1065 # ifdef USE_ICONV
1066 did_iconv = FALSE;
1067 # endif
1068 /* Skip conversion when it's already done (retry for wrong
1069 * "fileformat"). */
1070 if (tmpname == NULL)
1072 tmpname = readfile_charconvert(fname, fenc, &fd);
1073 if (tmpname == NULL)
1075 /* Conversion failed. Try another one. */
1076 advance_fenc = TRUE;
1077 if (fd < 0)
1079 /* Re-opening the original file failed! */
1080 EMSG(_("E202: Conversion made file unreadable!"));
1081 error = TRUE;
1082 goto failed;
1084 goto retry;
1088 else
1089 # endif
1091 if (fio_flags == 0
1092 # ifdef USE_ICONV
1093 && iconv_fd == (iconv_t)-1
1094 # endif
1097 /* Conversion wanted but we can't.
1098 * Try the next conversion in 'fileencodings' */
1099 advance_fenc = TRUE;
1100 goto retry;
1105 /* Set "can_retry" when it's possible to rewind the file and try with
1106 * another "fenc" value. It's FALSE when no other "fenc" to try, reading
1107 * stdin or fixed at a specific encoding. */
1108 can_retry = (*fenc != NUL && !read_stdin && !keep_dest_enc);
1109 #endif
1111 if (!skip_read)
1113 linerest = 0;
1114 filesize = 0;
1115 skip_count = lines_to_skip;
1116 read_count = lines_to_read;
1117 #ifdef FEAT_MBYTE
1118 conv_restlen = 0;
1119 #endif
1122 while (!error && !got_int)
1125 * We allocate as much space for the file as we can get, plus
1126 * space for the old line plus room for one terminating NUL.
1127 * The amount is limited by the fact that read() only can read
1128 * upto max_unsigned characters (and other things).
1130 #if SIZEOF_INT <= 2
1131 if (linerest >= 0x7ff0)
1133 ++split;
1134 *ptr = NL; /* split line by inserting a NL */
1135 size = 1;
1137 else
1138 #endif
1140 if (!skip_read)
1142 #if SIZEOF_INT > 2
1143 # if defined(SSIZE_MAX) && (SSIZE_MAX < 0x10000L)
1144 size = SSIZE_MAX; /* use max I/O size, 52K */
1145 # else
1146 size = 0x10000L; /* use buffer >= 64K */
1147 # endif
1148 #else
1149 size = 0x7ff0L - linerest; /* limit buffer to 32K */
1150 #endif
1152 for ( ; size >= 10; size = (long)((long_u)size >> 1))
1154 if ((new_buffer = lalloc((long_u)(size + linerest + 1),
1155 FALSE)) != NULL)
1156 break;
1158 if (new_buffer == NULL)
1160 do_outofmem_msg((long_u)(size * 2 + linerest + 1));
1161 error = TRUE;
1162 break;
1164 if (linerest) /* copy characters from the previous buffer */
1165 mch_memmove(new_buffer, ptr - linerest, (size_t)linerest);
1166 vim_free(buffer);
1167 buffer = new_buffer;
1168 ptr = buffer + linerest;
1169 line_start = buffer;
1171 #ifdef FEAT_MBYTE
1172 /* May need room to translate into.
1173 * For iconv() we don't really know the required space, use a
1174 * factor ICONV_MULT.
1175 * latin1 to utf-8: 1 byte becomes up to 2 bytes
1176 * utf-16 to utf-8: 2 bytes become up to 3 bytes, 4 bytes
1177 * become up to 4 bytes, size must be multiple of 2
1178 * ucs-2 to utf-8: 2 bytes become up to 3 bytes, size must be
1179 * multiple of 2
1180 * ucs-4 to utf-8: 4 bytes become up to 6 bytes, size must be
1181 * multiple of 4 */
1182 real_size = (int)size;
1183 # ifdef USE_ICONV
1184 if (iconv_fd != (iconv_t)-1)
1185 size = size / ICONV_MULT;
1186 else
1187 # endif
1188 if (fio_flags & FIO_LATIN1)
1189 size = size / 2;
1190 else if (fio_flags & (FIO_UCS2 | FIO_UTF16))
1191 size = (size * 2 / 3) & ~1;
1192 else if (fio_flags & FIO_UCS4)
1193 size = (size * 2 / 3) & ~3;
1194 else if (fio_flags == FIO_UCSBOM)
1195 size = size / ICONV_MULT; /* worst case */
1196 # ifdef WIN3264
1197 else if (fio_flags & FIO_CODEPAGE)
1198 size = size / ICONV_MULT; /* also worst case */
1199 # endif
1200 # ifdef MACOS_X
1201 else if (fio_flags & FIO_MACROMAN)
1202 size = size / ICONV_MULT; /* also worst case */
1203 # endif
1204 #endif
1206 #ifdef FEAT_MBYTE
1207 if (conv_restlen > 0)
1209 /* Insert unconverted bytes from previous line. */
1210 mch_memmove(ptr, conv_rest, conv_restlen);
1211 ptr += conv_restlen;
1212 size -= conv_restlen;
1214 #endif
1216 if (read_buffer)
1219 * Read bytes from curbuf. Used for converting text read
1220 * from stdin.
1222 if (read_buf_lnum > from)
1223 size = 0;
1224 else
1226 int n, ni;
1227 long tlen;
1229 tlen = 0;
1230 for (;;)
1232 p = ml_get(read_buf_lnum) + read_buf_col;
1233 n = (int)STRLEN(p);
1234 if ((int)tlen + n + 1 > size)
1236 /* Filled up to "size", append partial line.
1237 * Change NL to NUL to reverse the effect done
1238 * below. */
1239 n = (int)(size - tlen);
1240 for (ni = 0; ni < n; ++ni)
1242 if (p[ni] == NL)
1243 ptr[tlen++] = NUL;
1244 else
1245 ptr[tlen++] = p[ni];
1247 read_buf_col += n;
1248 break;
1250 else
1252 /* Append whole line and new-line. Change NL
1253 * to NUL to reverse the effect done below. */
1254 for (ni = 0; ni < n; ++ni)
1256 if (p[ni] == NL)
1257 ptr[tlen++] = NUL;
1258 else
1259 ptr[tlen++] = p[ni];
1261 ptr[tlen++] = NL;
1262 read_buf_col = 0;
1263 if (++read_buf_lnum > from)
1265 /* When the last line didn't have an
1266 * end-of-line don't add it now either. */
1267 if (!curbuf->b_p_eol)
1268 --tlen;
1269 size = tlen;
1270 break;
1276 else
1279 * Read bytes from the file.
1281 size = vim_read(fd, ptr, size);
1284 if (size <= 0)
1286 if (size < 0) /* read error */
1287 error = TRUE;
1288 #ifdef FEAT_MBYTE
1289 else if (conv_restlen > 0)
1291 /* Reached end-of-file but some trailing bytes could
1292 * not be converted. Truncated file? */
1293 if (conv_error == 0)
1294 conv_error = linecnt;
1295 if (bad_char_behavior != BAD_DROP)
1297 fio_flags = 0; /* don't convert this */
1298 # ifdef USE_ICONV
1299 if (iconv_fd != (iconv_t)-1)
1301 iconv_close(iconv_fd);
1302 iconv_fd = (iconv_t)-1;
1304 # endif
1305 if (bad_char_behavior == BAD_KEEP)
1307 /* Keep the trailing bytes as-is. */
1308 size = conv_restlen;
1309 ptr -= conv_restlen;
1311 else
1313 /* Replace the trailing bytes with the
1314 * replacement character. */
1315 size = 1;
1316 *--ptr = bad_char_behavior;
1318 conv_restlen = 0;
1321 #endif
1324 #ifdef FEAT_CRYPT
1326 * At start of file: Check for magic number of encryption.
1328 if (filesize == 0)
1329 cryptkey = check_for_cryptkey(cryptkey, ptr, &size,
1330 &filesize, newfile);
1332 * Decrypt the read bytes.
1334 if (cryptkey != NULL && size > 0)
1335 for (p = ptr; p < ptr + size; ++p)
1336 ZDECODE(*p);
1337 #endif
1339 skip_read = FALSE;
1341 #ifdef FEAT_MBYTE
1343 * At start of file (or after crypt magic number): Check for BOM.
1344 * Also check for a BOM for other Unicode encodings, but not after
1345 * converting with 'charconvert' or when a BOM has already been
1346 * found.
1348 if ((filesize == 0
1349 # ifdef FEAT_CRYPT
1350 || (filesize == CRYPT_MAGIC_LEN && cryptkey != NULL)
1351 # endif
1353 && (fio_flags == FIO_UCSBOM
1354 || (!curbuf->b_p_bomb
1355 && tmpname == NULL
1356 && (*fenc == 'u' || (*fenc == NUL && enc_utf8)))))
1358 char_u *ccname;
1359 int blen;
1361 /* no BOM detection in a short file or in binary mode */
1362 if (size < 2 || curbuf->b_p_bin)
1363 ccname = NULL;
1364 else
1365 ccname = check_for_bom(ptr, size, &blen,
1366 fio_flags == FIO_UCSBOM ? FIO_ALL : get_fio_flags(fenc));
1367 if (ccname != NULL)
1369 /* Remove BOM from the text */
1370 filesize += blen;
1371 size -= blen;
1372 mch_memmove(ptr, ptr + blen, (size_t)size);
1373 if (set_options)
1375 curbuf->b_p_bomb = TRUE;
1376 curbuf->b_start_bomb = TRUE;
1380 if (fio_flags == FIO_UCSBOM)
1382 if (ccname == NULL)
1384 /* No BOM detected: retry with next encoding. */
1385 advance_fenc = TRUE;
1387 else
1389 /* BOM detected: set "fenc" and jump back */
1390 if (fenc_alloced)
1391 vim_free(fenc);
1392 fenc = ccname;
1393 fenc_alloced = FALSE;
1395 /* retry reading without getting new bytes or rewinding */
1396 skip_read = TRUE;
1397 goto retry;
1400 #endif
1402 * Break here for a read error or end-of-file.
1404 if (size <= 0)
1405 break;
1407 #ifdef FEAT_MBYTE
1409 /* Include not converted bytes. */
1410 ptr -= conv_restlen;
1411 size += conv_restlen;
1412 conv_restlen = 0;
1414 # ifdef USE_ICONV
1415 if (iconv_fd != (iconv_t)-1)
1418 * Attempt conversion of the read bytes to 'encoding' using
1419 * iconv().
1421 const char *fromp;
1422 char *top;
1423 size_t from_size;
1424 size_t to_size;
1426 fromp = (char *)ptr;
1427 from_size = size;
1428 ptr += size;
1429 top = (char *)ptr;
1430 to_size = real_size - size;
1433 * If there is conversion error or not enough room try using
1434 * another conversion. Except for when there is no
1435 * alternative (help files).
1437 while ((iconv(iconv_fd, (void *)&fromp, &from_size,
1438 &top, &to_size)
1439 == (size_t)-1 && ICONV_ERRNO != ICONV_EINVAL)
1440 || from_size > CONV_RESTLEN)
1442 if (can_retry)
1443 goto rewind_retry;
1444 if (conv_error == 0)
1445 conv_error = readfile_linenr(linecnt,
1446 ptr, (char_u *)top);
1448 /* Deal with a bad byte and continue with the next. */
1449 ++fromp;
1450 --from_size;
1451 if (bad_char_behavior == BAD_KEEP)
1453 *top++ = *(fromp - 1);
1454 --to_size;
1456 else if (bad_char_behavior != BAD_DROP)
1458 *top++ = bad_char_behavior;
1459 --to_size;
1463 if (from_size > 0)
1465 /* Some remaining characters, keep them for the next
1466 * round. */
1467 mch_memmove(conv_rest, (char_u *)fromp, from_size);
1468 conv_restlen = (int)from_size;
1471 /* move the linerest to before the converted characters */
1472 line_start = ptr - linerest;
1473 mch_memmove(line_start, buffer, (size_t)linerest);
1474 size = (long)((char_u *)top - ptr);
1476 # endif
1478 # ifdef WIN3264
1479 if (fio_flags & FIO_CODEPAGE)
1481 char_u *src, *dst;
1482 WCHAR ucs2buf[3];
1483 int ucs2len;
1484 int codepage = FIO_GET_CP(fio_flags);
1485 int bytelen;
1486 int found_bad;
1487 char replstr[2];
1490 * Conversion from an MS-Windows codepage or UTF-8 to UTF-8 or
1491 * a codepage, using standard MS-Windows functions. This
1492 * requires two steps:
1493 * 1. convert from 'fileencoding' to ucs-2
1494 * 2. convert from ucs-2 to 'encoding'
1496 * Because there may be illegal bytes AND an incomplete byte
1497 * sequence at the end, we may have to do the conversion one
1498 * character at a time to get it right.
1501 /* Replacement string for WideCharToMultiByte(). */
1502 if (bad_char_behavior > 0)
1503 replstr[0] = bad_char_behavior;
1504 else
1505 replstr[0] = '?';
1506 replstr[1] = NUL;
1509 * Move the bytes to the end of the buffer, so that we have
1510 * room to put the result at the start.
1512 src = ptr + real_size - size;
1513 mch_memmove(src, ptr, size);
1516 * Do the conversion.
1518 dst = ptr;
1519 size = size;
1520 while (size > 0)
1522 found_bad = FALSE;
1524 # ifdef CP_UTF8 /* VC 4.1 doesn't define CP_UTF8 */
1525 if (codepage == CP_UTF8)
1527 /* Handle CP_UTF8 input ourselves to be able to handle
1528 * trailing bytes properly.
1529 * Get one UTF-8 character from src. */
1530 bytelen = (int)utf_ptr2len_len(src, size);
1531 if (bytelen > size)
1533 /* Only got some bytes of a character. Normally
1534 * it's put in "conv_rest", but if it's too long
1535 * deal with it as if they were illegal bytes. */
1536 if (bytelen <= CONV_RESTLEN)
1537 break;
1539 /* weird overlong byte sequence */
1540 bytelen = size;
1541 found_bad = TRUE;
1543 else
1545 int u8c = utf_ptr2char(src);
1547 if (u8c > 0xffff || (*src >= 0x80 && bytelen == 1))
1548 found_bad = TRUE;
1549 ucs2buf[0] = u8c;
1550 ucs2len = 1;
1553 else
1554 # endif
1556 /* We don't know how long the byte sequence is, try
1557 * from one to three bytes. */
1558 for (bytelen = 1; bytelen <= size && bytelen <= 3;
1559 ++bytelen)
1561 ucs2len = MultiByteToWideChar(codepage,
1562 MB_ERR_INVALID_CHARS,
1563 (LPCSTR)src, bytelen,
1564 ucs2buf, 3);
1565 if (ucs2len > 0)
1566 break;
1568 if (ucs2len == 0)
1570 /* If we have only one byte then it's probably an
1571 * incomplete byte sequence. Otherwise discard
1572 * one byte as a bad character. */
1573 if (size == 1)
1574 break;
1575 found_bad = TRUE;
1576 bytelen = 1;
1580 if (!found_bad)
1582 int i;
1584 /* Convert "ucs2buf[ucs2len]" to 'enc' in "dst". */
1585 if (enc_utf8)
1587 /* From UCS-2 to UTF-8. Cannot fail. */
1588 for (i = 0; i < ucs2len; ++i)
1589 dst += utf_char2bytes(ucs2buf[i], dst);
1591 else
1593 BOOL bad = FALSE;
1594 int dstlen;
1596 /* From UCS-2 to "enc_codepage". If the
1597 * conversion uses the default character "?",
1598 * the data doesn't fit in this encoding. */
1599 dstlen = WideCharToMultiByte(enc_codepage, 0,
1600 (LPCWSTR)ucs2buf, ucs2len,
1601 (LPSTR)dst, (int)(src - dst),
1602 replstr, &bad);
1603 if (bad)
1604 found_bad = TRUE;
1605 else
1606 dst += dstlen;
1610 if (found_bad)
1612 /* Deal with bytes we can't convert. */
1613 if (can_retry)
1614 goto rewind_retry;
1615 if (conv_error == 0)
1616 conv_error = readfile_linenr(linecnt, ptr, dst);
1617 if (bad_char_behavior != BAD_DROP)
1619 if (bad_char_behavior == BAD_KEEP)
1621 mch_memmove(dst, src, bytelen);
1622 dst += bytelen;
1624 else
1625 *dst++ = bad_char_behavior;
1629 src += bytelen;
1630 size -= bytelen;
1633 if (size > 0)
1635 /* An incomplete byte sequence remaining. */
1636 mch_memmove(conv_rest, src, size);
1637 conv_restlen = size;
1640 /* The new size is equal to how much "dst" was advanced. */
1641 size = (long)(dst - ptr);
1643 else
1644 # endif
1645 # ifdef MACOS_CONVERT
1646 if (fio_flags & FIO_MACROMAN)
1649 * Conversion from Apple MacRoman char encoding to UTF-8 or
1650 * latin1. This is in os_mac_conv.c.
1652 if (macroman2enc(ptr, &size, real_size) == FAIL)
1653 goto rewind_retry;
1655 else
1656 # endif
1657 if (fio_flags != 0)
1659 int u8c;
1660 char_u *dest;
1661 char_u *tail = NULL;
1664 * "enc_utf8" set: Convert Unicode or Latin1 to UTF-8.
1665 * "enc_utf8" not set: Convert Unicode to Latin1.
1666 * Go from end to start through the buffer, because the number
1667 * of bytes may increase.
1668 * "dest" points to after where the UTF-8 bytes go, "p" points
1669 * to after the next character to convert.
1671 dest = ptr + real_size;
1672 if (fio_flags == FIO_LATIN1 || fio_flags == FIO_UTF8)
1674 p = ptr + size;
1675 if (fio_flags == FIO_UTF8)
1677 /* Check for a trailing incomplete UTF-8 sequence */
1678 tail = ptr + size - 1;
1679 while (tail > ptr && (*tail & 0xc0) == 0x80)
1680 --tail;
1681 if (tail + utf_byte2len(*tail) <= ptr + size)
1682 tail = NULL;
1683 else
1684 p = tail;
1687 else if (fio_flags & (FIO_UCS2 | FIO_UTF16))
1689 /* Check for a trailing byte */
1690 p = ptr + (size & ~1);
1691 if (size & 1)
1692 tail = p;
1693 if ((fio_flags & FIO_UTF16) && p > ptr)
1695 /* Check for a trailing leading word */
1696 if (fio_flags & FIO_ENDIAN_L)
1698 u8c = (*--p << 8);
1699 u8c += *--p;
1701 else
1703 u8c = *--p;
1704 u8c += (*--p << 8);
1706 if (u8c >= 0xd800 && u8c <= 0xdbff)
1707 tail = p;
1708 else
1709 p += 2;
1712 else /* FIO_UCS4 */
1714 /* Check for trailing 1, 2 or 3 bytes */
1715 p = ptr + (size & ~3);
1716 if (size & 3)
1717 tail = p;
1720 /* If there is a trailing incomplete sequence move it to
1721 * conv_rest[]. */
1722 if (tail != NULL)
1724 conv_restlen = (int)((ptr + size) - tail);
1725 mch_memmove(conv_rest, (char_u *)tail, conv_restlen);
1726 size -= conv_restlen;
1730 while (p > ptr)
1732 if (fio_flags & FIO_LATIN1)
1733 u8c = *--p;
1734 else if (fio_flags & (FIO_UCS2 | FIO_UTF16))
1736 if (fio_flags & FIO_ENDIAN_L)
1738 u8c = (*--p << 8);
1739 u8c += *--p;
1741 else
1743 u8c = *--p;
1744 u8c += (*--p << 8);
1746 if ((fio_flags & FIO_UTF16)
1747 && u8c >= 0xdc00 && u8c <= 0xdfff)
1749 int u16c;
1751 if (p == ptr)
1753 /* Missing leading word. */
1754 if (can_retry)
1755 goto rewind_retry;
1756 if (conv_error == 0)
1757 conv_error = readfile_linenr(linecnt,
1758 ptr, p);
1759 if (bad_char_behavior == BAD_DROP)
1760 continue;
1761 if (bad_char_behavior != BAD_KEEP)
1762 u8c = bad_char_behavior;
1765 /* found second word of double-word, get the first
1766 * word and compute the resulting character */
1767 if (fio_flags & FIO_ENDIAN_L)
1769 u16c = (*--p << 8);
1770 u16c += *--p;
1772 else
1774 u16c = *--p;
1775 u16c += (*--p << 8);
1777 u8c = 0x10000 + ((u16c & 0x3ff) << 10)
1778 + (u8c & 0x3ff);
1780 /* Check if the word is indeed a leading word. */
1781 if (u16c < 0xd800 || u16c > 0xdbff)
1783 if (can_retry)
1784 goto rewind_retry;
1785 if (conv_error == 0)
1786 conv_error = readfile_linenr(linecnt,
1787 ptr, p);
1788 if (bad_char_behavior == BAD_DROP)
1789 continue;
1790 if (bad_char_behavior != BAD_KEEP)
1791 u8c = bad_char_behavior;
1795 else if (fio_flags & FIO_UCS4)
1797 if (fio_flags & FIO_ENDIAN_L)
1799 u8c = (*--p << 24);
1800 u8c += (*--p << 16);
1801 u8c += (*--p << 8);
1802 u8c += *--p;
1804 else /* big endian */
1806 u8c = *--p;
1807 u8c += (*--p << 8);
1808 u8c += (*--p << 16);
1809 u8c += (*--p << 24);
1812 else /* UTF-8 */
1814 if (*--p < 0x80)
1815 u8c = *p;
1816 else
1818 len = utf_head_off(ptr, p);
1819 p -= len;
1820 u8c = utf_ptr2char(p);
1821 if (len == 0)
1823 /* Not a valid UTF-8 character, retry with
1824 * another fenc when possible, otherwise just
1825 * report the error. */
1826 if (can_retry)
1827 goto rewind_retry;
1828 if (conv_error == 0)
1829 conv_error = readfile_linenr(linecnt,
1830 ptr, p);
1831 if (bad_char_behavior == BAD_DROP)
1832 continue;
1833 if (bad_char_behavior != BAD_KEEP)
1834 u8c = bad_char_behavior;
1838 if (enc_utf8) /* produce UTF-8 */
1840 dest -= utf_char2len(u8c);
1841 (void)utf_char2bytes(u8c, dest);
1843 else /* produce Latin1 */
1845 --dest;
1846 if (u8c >= 0x100)
1848 /* character doesn't fit in latin1, retry with
1849 * another fenc when possible, otherwise just
1850 * report the error. */
1851 if (can_retry)
1852 goto rewind_retry;
1853 if (conv_error == 0)
1854 conv_error = readfile_linenr(linecnt, ptr, p);
1855 if (bad_char_behavior == BAD_DROP)
1856 ++dest;
1857 else if (bad_char_behavior == BAD_KEEP)
1858 *dest = u8c;
1859 else if (eap != NULL && eap->bad_char != 0)
1860 *dest = bad_char_behavior;
1861 else
1862 *dest = 0xBF;
1864 else
1865 *dest = u8c;
1869 /* move the linerest to before the converted characters */
1870 line_start = dest - linerest;
1871 mch_memmove(line_start, buffer, (size_t)linerest);
1872 size = (long)((ptr + real_size) - dest);
1873 ptr = dest;
1875 else if (enc_utf8 && conv_error == 0 && !curbuf->b_p_bin)
1877 /* Reading UTF-8: Check if the bytes are valid UTF-8.
1878 * Need to start before "ptr" when part of the character was
1879 * read in the previous read() call. */
1880 for (p = ptr - utf_head_off(buffer, ptr); ; ++p)
1882 int todo = (int)((ptr + size) - p);
1883 int l;
1885 if (todo <= 0)
1886 break;
1887 if (*p >= 0x80)
1889 /* A length of 1 means it's an illegal byte. Accept
1890 * an incomplete character at the end though, the next
1891 * read() will get the next bytes, we'll check it
1892 * then. */
1893 l = utf_ptr2len_len(p, todo);
1894 if (l > todo)
1896 /* Incomplete byte sequence, the next read()
1897 * should get them and check the bytes. */
1898 p += todo;
1899 break;
1901 if (l == 1)
1903 /* Illegal byte. If we can try another encoding
1904 * do that. */
1905 if (can_retry)
1906 break;
1908 /* Remember the first linenr with an illegal byte */
1909 if (illegal_byte == 0)
1910 illegal_byte = readfile_linenr(linecnt, ptr, p);
1911 # ifdef USE_ICONV
1912 /* When we did a conversion report an error. */
1913 if (iconv_fd != (iconv_t)-1 && conv_error == 0)
1914 conv_error = readfile_linenr(linecnt, ptr, p);
1915 # endif
1917 /* Drop, keep or replace the bad byte. */
1918 if (bad_char_behavior == BAD_DROP)
1920 mch_memmove(p, p+1, todo - 1);
1921 --p;
1922 --size;
1924 else if (bad_char_behavior != BAD_KEEP)
1925 *p = bad_char_behavior;
1927 p += l - 1;
1930 if (p < ptr + size)
1932 /* Detected a UTF-8 error. */
1933 rewind_retry:
1934 /* Retry reading with another conversion. */
1935 # if defined(FEAT_EVAL) && defined(USE_ICONV)
1936 if (*p_ccv != NUL && iconv_fd != (iconv_t)-1)
1937 /* iconv() failed, try 'charconvert' */
1938 did_iconv = TRUE;
1939 else
1940 # endif
1941 /* use next item from 'fileencodings' */
1942 advance_fenc = TRUE;
1943 file_rewind = TRUE;
1944 goto retry;
1947 #endif
1949 /* count the number of characters (after conversion!) */
1950 filesize += size;
1953 * when reading the first part of a file: guess EOL type
1955 if (fileformat == EOL_UNKNOWN)
1957 /* First try finding a NL, for Dos and Unix */
1958 if (try_dos || try_unix)
1960 for (p = ptr; p < ptr + size; ++p)
1962 if (*p == NL)
1964 if (!try_unix
1965 || (try_dos && p > ptr && p[-1] == CAR))
1966 fileformat = EOL_DOS;
1967 else
1968 fileformat = EOL_UNIX;
1969 break;
1973 /* Don't give in to EOL_UNIX if EOL_MAC is more likely */
1974 if (fileformat == EOL_UNIX && try_mac)
1976 /* Need to reset the counters when retrying fenc. */
1977 try_mac = 1;
1978 try_unix = 1;
1979 for (; p >= ptr && *p != CAR; p--)
1981 if (p >= ptr)
1983 for (p = ptr; p < ptr + size; ++p)
1985 if (*p == NL)
1986 try_unix++;
1987 else if (*p == CAR)
1988 try_mac++;
1990 if (try_mac > try_unix)
1991 fileformat = EOL_MAC;
1996 /* No NL found: may use Mac format */
1997 if (fileformat == EOL_UNKNOWN && try_mac)
1998 fileformat = EOL_MAC;
2000 /* Still nothing found? Use first format in 'ffs' */
2001 if (fileformat == EOL_UNKNOWN)
2002 fileformat = default_fileformat();
2004 /* if editing a new file: may set p_tx and p_ff */
2005 if (set_options)
2006 set_fileformat(fileformat, OPT_LOCAL);
2011 * This loop is executed once for every character read.
2012 * Keep it fast!
2014 if (fileformat == EOL_MAC)
2016 --ptr;
2017 while (++ptr, --size >= 0)
2019 /* catch most common case first */
2020 if ((c = *ptr) != NUL && c != CAR && c != NL)
2021 continue;
2022 if (c == NUL)
2023 *ptr = NL; /* NULs are replaced by newlines! */
2024 else if (c == NL)
2025 *ptr = CAR; /* NLs are replaced by CRs! */
2026 else
2028 if (skip_count == 0)
2030 *ptr = NUL; /* end of line */
2031 len = (colnr_T) (ptr - line_start + 1);
2032 if (ml_append(lnum, line_start, len, newfile) == FAIL)
2034 error = TRUE;
2035 break;
2037 ++lnum;
2038 if (--read_count == 0)
2040 error = TRUE; /* break loop */
2041 line_start = ptr; /* nothing left to write */
2042 break;
2045 else
2046 --skip_count;
2047 line_start = ptr + 1;
2051 else
2053 --ptr;
2054 while (++ptr, --size >= 0)
2056 if ((c = *ptr) != NUL && c != NL) /* catch most common case */
2057 continue;
2058 if (c == NUL)
2059 *ptr = NL; /* NULs are replaced by newlines! */
2060 else
2062 if (skip_count == 0)
2064 *ptr = NUL; /* end of line */
2065 len = (colnr_T)(ptr - line_start + 1);
2066 if (fileformat == EOL_DOS)
2068 if (ptr[-1] == CAR) /* remove CR */
2070 ptr[-1] = NUL;
2071 --len;
2074 * Reading in Dos format, but no CR-LF found!
2075 * When 'fileformats' includes "unix", delete all
2076 * the lines read so far and start all over again.
2077 * Otherwise give an error message later.
2079 else if (ff_error != EOL_DOS)
2081 if ( try_unix
2082 && !read_stdin
2083 && (read_buffer
2084 || lseek(fd, (off_t)0L, SEEK_SET) == 0))
2086 fileformat = EOL_UNIX;
2087 if (set_options)
2088 set_fileformat(EOL_UNIX, OPT_LOCAL);
2089 file_rewind = TRUE;
2090 keep_fileformat = TRUE;
2091 goto retry;
2093 ff_error = EOL_DOS;
2096 if (ml_append(lnum, line_start, len, newfile) == FAIL)
2098 error = TRUE;
2099 break;
2101 ++lnum;
2102 if (--read_count == 0)
2104 error = TRUE; /* break loop */
2105 line_start = ptr; /* nothing left to write */
2106 break;
2109 else
2110 --skip_count;
2111 line_start = ptr + 1;
2115 linerest = (long)(ptr - line_start);
2116 ui_breakcheck();
2119 failed:
2120 /* not an error, max. number of lines reached */
2121 if (error && read_count == 0)
2122 error = FALSE;
2125 * If we get EOF in the middle of a line, note the fact and
2126 * complete the line ourselves.
2127 * In Dos format ignore a trailing CTRL-Z, unless 'binary' set.
2129 if (!error
2130 && !got_int
2131 && linerest != 0
2132 && !(!curbuf->b_p_bin
2133 && fileformat == EOL_DOS
2134 && *line_start == Ctrl_Z
2135 && ptr == line_start + 1))
2137 /* remember for when writing */
2138 if (set_options)
2139 curbuf->b_p_eol = FALSE;
2140 *ptr = NUL;
2141 if (ml_append(lnum, line_start,
2142 (colnr_T)(ptr - line_start + 1), newfile) == FAIL)
2143 error = TRUE;
2144 else
2145 read_no_eol_lnum = ++lnum;
2148 if (set_options)
2149 save_file_ff(curbuf); /* remember the current file format */
2151 #ifdef FEAT_CRYPT
2152 if (cryptkey != curbuf->b_p_key)
2153 vim_free(cryptkey);
2154 #endif
2156 #ifdef FEAT_MBYTE
2157 /* If editing a new file: set 'fenc' for the current buffer.
2158 * Also for ":read ++edit file". */
2159 if (set_options)
2160 set_string_option_direct((char_u *)"fenc", -1, fenc,
2161 OPT_FREE|OPT_LOCAL, 0);
2162 if (fenc_alloced)
2163 vim_free(fenc);
2164 # ifdef USE_ICONV
2165 if (iconv_fd != (iconv_t)-1)
2167 iconv_close(iconv_fd);
2168 iconv_fd = (iconv_t)-1;
2170 # endif
2171 #endif
2173 if (!read_buffer && !read_stdin)
2174 close(fd); /* errors are ignored */
2175 vim_free(buffer);
2177 #ifdef HAVE_DUP
2178 if (read_stdin)
2180 /* Use stderr for stdin, makes shell commands work. */
2181 close(0);
2182 dup(2);
2184 #endif
2186 #ifdef FEAT_MBYTE
2187 if (tmpname != NULL)
2189 mch_remove(tmpname); /* delete converted file */
2190 vim_free(tmpname);
2192 #endif
2193 --no_wait_return; /* may wait for return now */
2196 * In recovery mode everything but autocommands is skipped.
2198 if (!recoverymode)
2200 /* need to delete the last line, which comes from the empty buffer */
2201 if (newfile && wasempty && !(curbuf->b_ml.ml_flags & ML_EMPTY))
2203 #ifdef FEAT_NETBEANS_INTG
2204 netbeansFireChanges = 0;
2205 #endif
2206 ml_delete(curbuf->b_ml.ml_line_count, FALSE);
2207 #ifdef FEAT_NETBEANS_INTG
2208 netbeansFireChanges = 1;
2209 #endif
2210 --linecnt;
2212 linecnt = curbuf->b_ml.ml_line_count - linecnt;
2213 if (filesize == 0)
2214 linecnt = 0;
2215 if (newfile || read_buffer)
2217 redraw_curbuf_later(NOT_VALID);
2218 #ifdef FEAT_DIFF
2219 /* After reading the text into the buffer the diff info needs to
2220 * be updated. */
2221 diff_invalidate(curbuf);
2222 #endif
2223 #ifdef FEAT_FOLDING
2224 /* All folds in the window are invalid now. Mark them for update
2225 * before triggering autocommands. */
2226 foldUpdateAll(curwin);
2227 #endif
2229 else if (linecnt) /* appended at least one line */
2230 appended_lines_mark(from, linecnt);
2232 #ifndef ALWAYS_USE_GUI
2234 * If we were reading from the same terminal as where messages go,
2235 * the screen will have been messed up.
2236 * Switch on raw mode now and clear the screen.
2238 if (read_stdin)
2240 settmode(TMODE_RAW); /* set to raw mode */
2241 starttermcap();
2242 screenclear();
2244 #endif
2246 if (got_int)
2248 if (!(flags & READ_DUMMY))
2250 filemess(curbuf, sfname, (char_u *)_(e_interr), 0);
2251 if (newfile)
2252 curbuf->b_p_ro = TRUE; /* must use "w!" now */
2254 msg_scroll = msg_save;
2255 #ifdef FEAT_VIMINFO
2256 check_marks_read();
2257 #endif
2258 return OK; /* an interrupt isn't really an error */
2261 if (!filtering && !(flags & READ_DUMMY))
2263 msg_add_fname(curbuf, sfname); /* fname in IObuff with quotes */
2264 c = FALSE;
2266 #ifdef UNIX
2267 # ifdef S_ISFIFO
2268 if (S_ISFIFO(perm)) /* fifo or socket */
2270 STRCAT(IObuff, _("[fifo/socket]"));
2271 c = TRUE;
2273 # else
2274 # ifdef S_IFIFO
2275 if ((perm & S_IFMT) == S_IFIFO) /* fifo */
2277 STRCAT(IObuff, _("[fifo]"));
2278 c = TRUE;
2280 # endif
2281 # ifdef S_IFSOCK
2282 if ((perm & S_IFMT) == S_IFSOCK) /* or socket */
2284 STRCAT(IObuff, _("[socket]"));
2285 c = TRUE;
2287 # endif
2288 # endif
2289 # ifdef OPEN_CHR_FILES
2290 if (S_ISCHR(perm)) /* or character special */
2292 STRCAT(IObuff, _("[character special]"));
2293 c = TRUE;
2295 # endif
2296 #endif
2297 if (curbuf->b_p_ro)
2299 STRCAT(IObuff, shortmess(SHM_RO) ? _("[RO]") : _("[readonly]"));
2300 c = TRUE;
2302 if (read_no_eol_lnum)
2304 msg_add_eol();
2305 c = TRUE;
2307 if (ff_error == EOL_DOS)
2309 STRCAT(IObuff, _("[CR missing]"));
2310 c = TRUE;
2312 if (ff_error == EOL_MAC)
2314 STRCAT(IObuff, _("[NL found]"));
2315 c = TRUE;
2317 if (split)
2319 STRCAT(IObuff, _("[long lines split]"));
2320 c = TRUE;
2322 #ifdef FEAT_MBYTE
2323 if (notconverted)
2325 STRCAT(IObuff, _("[NOT converted]"));
2326 c = TRUE;
2328 else if (converted)
2330 STRCAT(IObuff, _("[converted]"));
2331 c = TRUE;
2333 #endif
2334 #ifdef FEAT_CRYPT
2335 if (cryptkey != NULL)
2337 STRCAT(IObuff, _("[crypted]"));
2338 c = TRUE;
2340 #endif
2341 #ifdef FEAT_MBYTE
2342 if (conv_error != 0)
2344 sprintf((char *)IObuff + STRLEN(IObuff),
2345 _("[CONVERSION ERROR in line %ld]"), (long)conv_error);
2346 c = TRUE;
2348 else if (illegal_byte > 0)
2350 sprintf((char *)IObuff + STRLEN(IObuff),
2351 _("[ILLEGAL BYTE in line %ld]"), (long)illegal_byte);
2352 c = TRUE;
2354 else
2355 #endif
2356 if (error)
2358 STRCAT(IObuff, _("[READ ERRORS]"));
2359 c = TRUE;
2361 if (msg_add_fileformat(fileformat))
2362 c = TRUE;
2363 #ifdef FEAT_CRYPT
2364 if (cryptkey != NULL)
2365 msg_add_lines(c, (long)linecnt, filesize - CRYPT_MAGIC_LEN);
2366 else
2367 #endif
2368 msg_add_lines(c, (long)linecnt, filesize);
2370 vim_free(keep_msg);
2371 keep_msg = NULL;
2372 msg_scrolled_ign = TRUE;
2373 #ifdef ALWAYS_USE_GUI
2374 /* Don't show the message when reading stdin, it would end up in a
2375 * message box (which might be shown when exiting!) */
2376 if (read_stdin || read_buffer)
2377 p = msg_may_trunc(FALSE, IObuff);
2378 else
2379 #endif
2380 p = msg_trunc_attr(IObuff, FALSE, 0);
2381 if (read_stdin || read_buffer || restart_edit != 0
2382 || (msg_scrolled != 0 && !need_wait_return))
2383 /* Need to repeat the message after redrawing when:
2384 * - When reading from stdin (the screen will be cleared next).
2385 * - When restart_edit is set (otherwise there will be a delay
2386 * before redrawing).
2387 * - When the screen was scrolled but there is no wait-return
2388 * prompt. */
2389 set_keep_msg(p, 0);
2390 msg_scrolled_ign = FALSE;
2393 /* with errors writing the file requires ":w!" */
2394 if (newfile && (error
2395 #ifdef FEAT_MBYTE
2396 || conv_error != 0
2397 || (illegal_byte > 0 && bad_char_behavior != BAD_KEEP)
2398 #endif
2400 curbuf->b_p_ro = TRUE;
2402 u_clearline(); /* cannot use "U" command after adding lines */
2405 * In Ex mode: cursor at last new line.
2406 * Otherwise: cursor at first new line.
2408 if (exmode_active)
2409 curwin->w_cursor.lnum = from + linecnt;
2410 else
2411 curwin->w_cursor.lnum = from + 1;
2412 check_cursor_lnum();
2413 beginline(BL_WHITE | BL_FIX); /* on first non-blank */
2416 * Set '[ and '] marks to the newly read lines.
2418 curbuf->b_op_start.lnum = from + 1;
2419 curbuf->b_op_start.col = 0;
2420 curbuf->b_op_end.lnum = from + linecnt;
2421 curbuf->b_op_end.col = 0;
2423 #ifdef WIN32
2425 * Work around a weird problem: When a file has two links (only
2426 * possible on NTFS) and we write through one link, then stat() it
2427 * throught the other link, the timestamp information may be wrong.
2428 * It's correct again after reading the file, thus reset the timestamp
2429 * here.
2431 if (newfile && !read_stdin && !read_buffer
2432 && mch_stat((char *)fname, &st) >= 0)
2434 buf_store_time(curbuf, &st, fname);
2435 curbuf->b_mtime_read = curbuf->b_mtime;
2437 #endif
2439 msg_scroll = msg_save;
2441 #ifdef FEAT_VIMINFO
2443 * Get the marks before executing autocommands, so they can be used there.
2445 check_marks_read();
2446 #endif
2449 * Trick: We remember if the last line of the read didn't have
2450 * an eol for when writing it again. This is required for
2451 * ":autocmd FileReadPost *.gz set bin|'[,']!gunzip" to work.
2453 write_no_eol_lnum = read_no_eol_lnum;
2455 #ifdef FEAT_AUTOCMD
2456 if (!read_stdin && !read_buffer)
2458 int m = msg_scroll;
2459 int n = msg_scrolled;
2461 /* Save the fileformat now, otherwise the buffer will be considered
2462 * modified if the format/encoding was automatically detected. */
2463 if (set_options)
2464 save_file_ff(curbuf);
2467 * The output from the autocommands should not overwrite anything and
2468 * should not be overwritten: Set msg_scroll, restore its value if no
2469 * output was done.
2471 msg_scroll = TRUE;
2472 if (filtering)
2473 apply_autocmds_exarg(EVENT_FILTERREADPOST, NULL, sfname,
2474 FALSE, curbuf, eap);
2475 else if (newfile)
2476 apply_autocmds_exarg(EVENT_BUFREADPOST, NULL, sfname,
2477 FALSE, curbuf, eap);
2478 else
2479 apply_autocmds_exarg(EVENT_FILEREADPOST, sfname, sfname,
2480 FALSE, NULL, eap);
2481 if (msg_scrolled == n)
2482 msg_scroll = m;
2483 #ifdef FEAT_EVAL
2484 if (aborting()) /* autocmds may abort script processing */
2485 return FAIL;
2486 #endif
2488 #endif
2490 if (recoverymode && error)
2491 return FAIL;
2492 return OK;
2495 #ifdef OPEN_CHR_FILES
2497 * Returns TRUE if the file name argument is of the form "/dev/fd/\d\+",
2498 * which is the name of files used for process substitution output by
2499 * some shells on some operating systems, e.g., bash on SunOS.
2500 * Do not accept "/dev/fd/[012]", opening these may hang Vim.
2502 static int
2503 is_dev_fd_file(fname)
2504 char_u *fname;
2506 return (STRNCMP(fname, "/dev/fd/", 8) == 0
2507 && VIM_ISDIGIT(fname[8])
2508 && *skipdigits(fname + 9) == NUL
2509 && (fname[9] != NUL
2510 || (fname[8] != '0' && fname[8] != '1' && fname[8] != '2')));
2512 #endif
2514 #ifdef FEAT_MBYTE
2517 * From the current line count and characters read after that, estimate the
2518 * line number where we are now.
2519 * Used for error messages that include a line number.
2521 static linenr_T
2522 readfile_linenr(linecnt, p, endp)
2523 linenr_T linecnt; /* line count before reading more bytes */
2524 char_u *p; /* start of more bytes read */
2525 char_u *endp; /* end of more bytes read */
2527 char_u *s;
2528 linenr_T lnum;
2530 lnum = curbuf->b_ml.ml_line_count - linecnt + 1;
2531 for (s = p; s < endp; ++s)
2532 if (*s == '\n')
2533 ++lnum;
2534 return lnum;
2536 #endif
2539 * Fill "*eap" to force the 'fileencoding', 'fileformat' and 'binary to be
2540 * equal to the buffer "buf". Used for calling readfile().
2541 * Returns OK or FAIL.
2544 prep_exarg(eap, buf)
2545 exarg_T *eap;
2546 buf_T *buf;
2548 eap->cmd = alloc((unsigned)(STRLEN(buf->b_p_ff)
2549 #ifdef FEAT_MBYTE
2550 + STRLEN(buf->b_p_fenc)
2551 #endif
2552 + 15));
2553 if (eap->cmd == NULL)
2554 return FAIL;
2556 #ifdef FEAT_MBYTE
2557 sprintf((char *)eap->cmd, "e ++ff=%s ++enc=%s", buf->b_p_ff, buf->b_p_fenc);
2558 eap->force_enc = 14 + (int)STRLEN(buf->b_p_ff);
2559 eap->bad_char = buf->b_bad_char;
2560 #else
2561 sprintf((char *)eap->cmd, "e ++ff=%s", buf->b_p_ff);
2562 #endif
2563 eap->force_ff = 7;
2565 eap->force_bin = buf->b_p_bin ? FORCE_BIN : FORCE_NOBIN;
2566 eap->read_edit = FALSE;
2567 eap->forceit = FALSE;
2568 return OK;
2571 #ifdef FEAT_MBYTE
2573 * Find next fileencoding to use from 'fileencodings'.
2574 * "pp" points to fenc_next. It's advanced to the next item.
2575 * When there are no more items, an empty string is returned and *pp is set to
2576 * NULL.
2577 * When *pp is not set to NULL, the result is in allocated memory.
2579 static char_u *
2580 next_fenc(pp)
2581 char_u **pp;
2583 char_u *p;
2584 char_u *r;
2586 if (**pp == NUL)
2588 *pp = NULL;
2589 return (char_u *)"";
2591 p = vim_strchr(*pp, ',');
2592 if (p == NULL)
2594 r = enc_canonize(*pp);
2595 *pp += STRLEN(*pp);
2597 else
2599 r = vim_strnsave(*pp, (int)(p - *pp));
2600 *pp = p + 1;
2601 if (r != NULL)
2603 p = enc_canonize(r);
2604 vim_free(r);
2605 r = p;
2608 if (r == NULL) /* out of memory */
2610 r = (char_u *)"";
2611 *pp = NULL;
2613 return r;
2616 # ifdef FEAT_EVAL
2618 * Convert a file with the 'charconvert' expression.
2619 * This closes the file which is to be read, converts it and opens the
2620 * resulting file for reading.
2621 * Returns name of the resulting converted file (the caller should delete it
2622 * after reading it).
2623 * Returns NULL if the conversion failed ("*fdp" is not set) .
2625 static char_u *
2626 readfile_charconvert(fname, fenc, fdp)
2627 char_u *fname; /* name of input file */
2628 char_u *fenc; /* converted from */
2629 int *fdp; /* in/out: file descriptor of file */
2631 char_u *tmpname;
2632 char_u *errmsg = NULL;
2634 tmpname = vim_tempname('r');
2635 if (tmpname == NULL)
2636 errmsg = (char_u *)_("Can't find temp file for conversion");
2637 else
2639 close(*fdp); /* close the input file, ignore errors */
2640 *fdp = -1;
2641 if (eval_charconvert(fenc, enc_utf8 ? (char_u *)"utf-8" : p_enc,
2642 fname, tmpname) == FAIL)
2643 errmsg = (char_u *)_("Conversion with 'charconvert' failed");
2644 if (errmsg == NULL && (*fdp = mch_open((char *)tmpname,
2645 O_RDONLY | O_EXTRA, 0)) < 0)
2646 errmsg = (char_u *)_("can't read output of 'charconvert'");
2649 if (errmsg != NULL)
2651 /* Don't use emsg(), it breaks mappings, the retry with
2652 * another type of conversion might still work. */
2653 MSG(errmsg);
2654 if (tmpname != NULL)
2656 mch_remove(tmpname); /* delete converted file */
2657 vim_free(tmpname);
2658 tmpname = NULL;
2662 /* If the input file is closed, open it (caller should check for error). */
2663 if (*fdp < 0)
2664 *fdp = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
2666 return tmpname;
2668 # endif
2670 #endif
2672 #ifdef FEAT_VIMINFO
2674 * Read marks for the current buffer from the viminfo file, when we support
2675 * buffer marks and the buffer has a name.
2677 static void
2678 check_marks_read()
2680 if (!curbuf->b_marks_read && get_viminfo_parameter('\'') > 0
2681 && curbuf->b_ffname != NULL)
2682 read_viminfo(NULL, FALSE, TRUE, FALSE);
2684 /* Always set b_marks_read; needed when 'viminfo' is changed to include
2685 * the ' parameter after opening a buffer. */
2686 curbuf->b_marks_read = TRUE;
2688 #endif
2690 #ifdef FEAT_CRYPT
2692 * Check for magic number used for encryption.
2693 * If found, the magic number is removed from ptr[*sizep] and *sizep and
2694 * *filesizep are updated.
2695 * Return the (new) encryption key, NULL for no encryption.
2697 static char_u *
2698 check_for_cryptkey(cryptkey, ptr, sizep, filesizep, newfile)
2699 char_u *cryptkey; /* previous encryption key or NULL */
2700 char_u *ptr; /* pointer to read bytes */
2701 long *sizep; /* length of read bytes */
2702 long *filesizep; /* nr of bytes used from file */
2703 int newfile; /* editing a new buffer */
2705 if (*sizep >= CRYPT_MAGIC_LEN
2706 && STRNCMP(ptr, CRYPT_MAGIC, CRYPT_MAGIC_LEN) == 0)
2708 if (cryptkey == NULL)
2710 if (*curbuf->b_p_key)
2711 cryptkey = curbuf->b_p_key;
2712 else
2714 /* When newfile is TRUE, store the typed key
2715 * in the 'key' option and don't free it. */
2716 cryptkey = get_crypt_key(newfile, FALSE);
2717 /* check if empty key entered */
2718 if (cryptkey != NULL && *cryptkey == NUL)
2720 if (cryptkey != curbuf->b_p_key)
2721 vim_free(cryptkey);
2722 cryptkey = NULL;
2727 if (cryptkey != NULL)
2729 crypt_init_keys(cryptkey);
2731 /* Remove magic number from the text */
2732 *filesizep += CRYPT_MAGIC_LEN;
2733 *sizep -= CRYPT_MAGIC_LEN;
2734 mch_memmove(ptr, ptr + CRYPT_MAGIC_LEN, (size_t)*sizep);
2737 /* When starting to edit a new file which does not have
2738 * encryption, clear the 'key' option, except when
2739 * starting up (called with -x argument) */
2740 else if (newfile && *curbuf->b_p_key && !starting)
2741 set_option_value((char_u *)"key", 0L, (char_u *)"", OPT_LOCAL);
2743 return cryptkey;
2745 #endif
2747 #ifdef UNIX
2748 static void
2749 set_file_time(fname, atime, mtime)
2750 char_u *fname;
2751 time_t atime; /* access time */
2752 time_t mtime; /* modification time */
2754 # if defined(HAVE_UTIME) && defined(HAVE_UTIME_H)
2755 struct utimbuf buf;
2757 buf.actime = atime;
2758 buf.modtime = mtime;
2759 (void)utime((char *)fname, &buf);
2760 # else
2761 # if defined(HAVE_UTIMES)
2762 struct timeval tvp[2];
2764 tvp[0].tv_sec = atime;
2765 tvp[0].tv_usec = 0;
2766 tvp[1].tv_sec = mtime;
2767 tvp[1].tv_usec = 0;
2768 # ifdef NeXT
2769 (void)utimes((char *)fname, tvp);
2770 # else
2771 (void)utimes((char *)fname, (const struct timeval *)&tvp);
2772 # endif
2773 # endif
2774 # endif
2776 #endif /* UNIX */
2778 #if defined(VMS) && !defined(MIN)
2779 /* Older DECC compiler for VAX doesn't define MIN() */
2780 # define MIN(a, b) ((a) < (b) ? (a) : (b))
2781 #endif
2784 * Return TRUE if a file appears to be read-only from the file permissions.
2787 check_file_readonly(fname, perm)
2788 char_u *fname; /* full path to file */
2789 int perm; /* known permissions on file */
2791 #ifndef USE_MCH_ACCESS
2792 int fd = 0;
2793 #endif
2795 return (
2796 #ifdef USE_MCH_ACCESS
2797 # ifdef UNIX
2798 (perm & 0222) == 0 ||
2799 # endif
2800 mch_access((char *)fname, W_OK)
2801 #else
2802 (fd = mch_open((char *)fname, O_RDWR | O_EXTRA, 0)) < 0
2803 ? TRUE : (close(fd), FALSE)
2804 #endif
2810 * buf_write() - write to file "fname" lines "start" through "end"
2812 * We do our own buffering here because fwrite() is so slow.
2814 * If "forceit" is true, we don't care for errors when attempting backups.
2815 * In case of an error everything possible is done to restore the original
2816 * file. But when "forceit" is TRUE, we risk loosing it.
2818 * When "reset_changed" is TRUE and "append" == FALSE and "start" == 1 and
2819 * "end" == curbuf->b_ml.ml_line_count, reset curbuf->b_changed.
2821 * This function must NOT use NameBuff (because it's called by autowrite()).
2823 * return FAIL for failure, OK otherwise
2826 buf_write(buf, fname, sfname, start, end, eap, append, forceit,
2827 reset_changed, filtering)
2828 buf_T *buf;
2829 char_u *fname;
2830 char_u *sfname;
2831 linenr_T start, end;
2832 exarg_T *eap; /* for forced 'ff' and 'fenc', can be
2833 NULL! */
2834 int append; /* append to the file */
2835 int forceit;
2836 int reset_changed;
2837 int filtering;
2839 int fd;
2840 char_u *backup = NULL;
2841 int backup_copy = FALSE; /* copy the original file? */
2842 int dobackup;
2843 char_u *ffname;
2844 char_u *wfname = NULL; /* name of file to write to */
2845 char_u *s;
2846 char_u *ptr;
2847 char_u c;
2848 int len;
2849 linenr_T lnum;
2850 long nchars;
2851 char_u *errmsg = NULL;
2852 char_u *errnum = NULL;
2853 char_u *buffer;
2854 char_u smallbuf[SMBUFSIZE];
2855 char_u *backup_ext;
2856 int bufsize;
2857 long perm; /* file permissions */
2858 int retval = OK;
2859 int newfile = FALSE; /* TRUE if file doesn't exist yet */
2860 int msg_save = msg_scroll;
2861 int overwriting; /* TRUE if writing over original */
2862 int no_eol = FALSE; /* no end-of-line written */
2863 int device = FALSE; /* writing to a device */
2864 struct stat st_old;
2865 int prev_got_int = got_int;
2866 int file_readonly = FALSE; /* overwritten file is read-only */
2867 static char *err_readonly = "is read-only (cannot override: \"W\" in 'cpoptions')";
2868 #if defined(UNIX) || defined(__EMX__XX) /*XXX fix me sometime? */
2869 int made_writable = FALSE; /* 'w' bit has been set */
2870 #endif
2871 /* writing everything */
2872 int whole = (start == 1 && end == buf->b_ml.ml_line_count);
2873 #ifdef FEAT_AUTOCMD
2874 linenr_T old_line_count = buf->b_ml.ml_line_count;
2875 #endif
2876 int attr;
2877 int fileformat;
2878 int write_bin;
2879 struct bw_info write_info; /* info for buf_write_bytes() */
2880 #ifdef FEAT_MBYTE
2881 int converted = FALSE;
2882 int notconverted = FALSE;
2883 char_u *fenc; /* effective 'fileencoding' */
2884 char_u *fenc_tofree = NULL; /* allocated "fenc" */
2885 #endif
2886 #ifdef HAS_BW_FLAGS
2887 int wb_flags = 0;
2888 #endif
2889 #ifdef HAVE_ACL
2890 vim_acl_T acl = NULL; /* ACL copied from original file to
2891 backup or new file */
2892 #endif
2894 if (fname == NULL || *fname == NUL) /* safety check */
2895 return FAIL;
2898 * Disallow writing from .exrc and .vimrc in current directory for
2899 * security reasons.
2901 if (check_secure())
2902 return FAIL;
2904 /* Avoid a crash for a long name. */
2905 if (STRLEN(fname) >= MAXPATHL)
2907 EMSG(_(e_longname));
2908 return FAIL;
2911 #ifdef FEAT_MBYTE
2912 /* must init bw_conv_buf and bw_iconv_fd before jumping to "fail" */
2913 write_info.bw_conv_buf = NULL;
2914 write_info.bw_conv_error = FALSE;
2915 write_info.bw_restlen = 0;
2916 # ifdef USE_ICONV
2917 write_info.bw_iconv_fd = (iconv_t)-1;
2918 # endif
2919 #endif
2921 /* After writing a file changedtick changes but we don't want to display
2922 * the line. */
2923 ex_no_reprint = TRUE;
2926 * If there is no file name yet, use the one for the written file.
2927 * BF_NOTEDITED is set to reflect this (in case the write fails).
2928 * Don't do this when the write is for a filter command.
2929 * Don't do this when appending.
2930 * Only do this when 'cpoptions' contains the 'F' flag.
2932 if (buf->b_ffname == NULL
2933 && reset_changed
2934 && whole
2935 && buf == curbuf
2936 #ifdef FEAT_QUICKFIX
2937 && !bt_nofile(buf)
2938 #endif
2939 && !filtering
2940 && (!append || vim_strchr(p_cpo, CPO_FNAMEAPP) != NULL)
2941 && vim_strchr(p_cpo, CPO_FNAMEW) != NULL)
2943 if (set_rw_fname(fname, sfname) == FAIL)
2944 return FAIL;
2945 buf = curbuf; /* just in case autocmds made "buf" invalid */
2948 if (sfname == NULL)
2949 sfname = fname;
2951 * For Unix: Use the short file name whenever possible.
2952 * Avoids problems with networks and when directory names are changed.
2953 * Don't do this for MS-DOS, a "cd" in a sub-shell may have moved us to
2954 * another directory, which we don't detect
2956 ffname = fname; /* remember full fname */
2957 #ifdef UNIX
2958 fname = sfname;
2959 #endif
2961 if (buf->b_ffname != NULL && fnamecmp(ffname, buf->b_ffname) == 0)
2962 overwriting = TRUE;
2963 else
2964 overwriting = FALSE;
2966 if (exiting)
2967 settmode(TMODE_COOK); /* when exiting allow typahead now */
2969 ++no_wait_return; /* don't wait for return yet */
2972 * Set '[ and '] marks to the lines to be written.
2974 buf->b_op_start.lnum = start;
2975 buf->b_op_start.col = 0;
2976 buf->b_op_end.lnum = end;
2977 buf->b_op_end.col = 0;
2979 #ifdef FEAT_AUTOCMD
2981 aco_save_T aco;
2982 int buf_ffname = FALSE;
2983 int buf_sfname = FALSE;
2984 int buf_fname_f = FALSE;
2985 int buf_fname_s = FALSE;
2986 int did_cmd = FALSE;
2987 int nofile_err = FALSE;
2988 int empty_memline = (buf->b_ml.ml_mfp == NULL);
2991 * Apply PRE aucocommands.
2992 * Set curbuf to the buffer to be written.
2993 * Careful: The autocommands may call buf_write() recursively!
2995 if (ffname == buf->b_ffname)
2996 buf_ffname = TRUE;
2997 if (sfname == buf->b_sfname)
2998 buf_sfname = TRUE;
2999 if (fname == buf->b_ffname)
3000 buf_fname_f = TRUE;
3001 if (fname == buf->b_sfname)
3002 buf_fname_s = TRUE;
3004 /* set curwin/curbuf to buf and save a few things */
3005 aucmd_prepbuf(&aco, buf);
3007 if (append)
3009 if (!(did_cmd = apply_autocmds_exarg(EVENT_FILEAPPENDCMD,
3010 sfname, sfname, FALSE, curbuf, eap)))
3012 #ifdef FEAT_QUICKFIX
3013 if (overwriting && bt_nofile(curbuf))
3014 nofile_err = TRUE;
3015 else
3016 #endif
3017 apply_autocmds_exarg(EVENT_FILEAPPENDPRE,
3018 sfname, sfname, FALSE, curbuf, eap);
3021 else if (filtering)
3023 apply_autocmds_exarg(EVENT_FILTERWRITEPRE,
3024 NULL, sfname, FALSE, curbuf, eap);
3026 else if (reset_changed && whole)
3028 if (!(did_cmd = apply_autocmds_exarg(EVENT_BUFWRITECMD,
3029 sfname, sfname, FALSE, curbuf, eap)))
3031 #ifdef FEAT_QUICKFIX
3032 if (overwriting && bt_nofile(curbuf))
3033 nofile_err = TRUE;
3034 else
3035 #endif
3036 apply_autocmds_exarg(EVENT_BUFWRITEPRE,
3037 sfname, sfname, FALSE, curbuf, eap);
3040 else
3042 if (!(did_cmd = apply_autocmds_exarg(EVENT_FILEWRITECMD,
3043 sfname, sfname, FALSE, curbuf, eap)))
3045 #ifdef FEAT_QUICKFIX
3046 if (overwriting && bt_nofile(curbuf))
3047 nofile_err = TRUE;
3048 else
3049 #endif
3050 apply_autocmds_exarg(EVENT_FILEWRITEPRE,
3051 sfname, sfname, FALSE, curbuf, eap);
3055 /* restore curwin/curbuf and a few other things */
3056 aucmd_restbuf(&aco);
3059 * In three situations we return here and don't write the file:
3060 * 1. the autocommands deleted or unloaded the buffer.
3061 * 2. The autocommands abort script processing.
3062 * 3. If one of the "Cmd" autocommands was executed.
3064 if (!buf_valid(buf))
3065 buf = NULL;
3066 if (buf == NULL || (buf->b_ml.ml_mfp == NULL && !empty_memline)
3067 || did_cmd || nofile_err
3068 #ifdef FEAT_EVAL
3069 || aborting()
3070 #endif
3073 --no_wait_return;
3074 msg_scroll = msg_save;
3075 if (nofile_err)
3076 EMSG(_("E676: No matching autocommands for acwrite buffer"));
3078 if (nofile_err
3079 #ifdef FEAT_EVAL
3080 || aborting()
3081 #endif
3083 /* An aborting error, interrupt or exception in the
3084 * autocommands. */
3085 return FAIL;
3086 if (did_cmd)
3088 if (buf == NULL)
3089 /* The buffer was deleted. We assume it was written
3090 * (can't retry anyway). */
3091 return OK;
3092 if (overwriting)
3094 /* Assume the buffer was written, update the timestamp. */
3095 ml_timestamp(buf);
3096 if (append)
3097 buf->b_flags &= ~BF_NEW;
3098 else
3099 buf->b_flags &= ~BF_WRITE_MASK;
3101 if (reset_changed && buf->b_changed && !append
3102 && (overwriting || vim_strchr(p_cpo, CPO_PLUS) != NULL))
3103 /* Buffer still changed, the autocommands didn't work
3104 * properly. */
3105 return FAIL;
3106 return OK;
3108 #ifdef FEAT_EVAL
3109 if (!aborting())
3110 #endif
3111 EMSG(_("E203: Autocommands deleted or unloaded buffer to be written"));
3112 return FAIL;
3116 * The autocommands may have changed the number of lines in the file.
3117 * When writing the whole file, adjust the end.
3118 * When writing part of the file, assume that the autocommands only
3119 * changed the number of lines that are to be written (tricky!).
3121 if (buf->b_ml.ml_line_count != old_line_count)
3123 if (whole) /* write all */
3124 end = buf->b_ml.ml_line_count;
3125 else if (buf->b_ml.ml_line_count > old_line_count) /* more lines */
3126 end += buf->b_ml.ml_line_count - old_line_count;
3127 else /* less lines */
3129 end -= old_line_count - buf->b_ml.ml_line_count;
3130 if (end < start)
3132 --no_wait_return;
3133 msg_scroll = msg_save;
3134 EMSG(_("E204: Autocommand changed number of lines in unexpected way"));
3135 return FAIL;
3141 * The autocommands may have changed the name of the buffer, which may
3142 * be kept in fname, ffname and sfname.
3144 if (buf_ffname)
3145 ffname = buf->b_ffname;
3146 if (buf_sfname)
3147 sfname = buf->b_sfname;
3148 if (buf_fname_f)
3149 fname = buf->b_ffname;
3150 if (buf_fname_s)
3151 fname = buf->b_sfname;
3153 #endif
3155 #ifdef FEAT_NETBEANS_INTG
3156 if (usingNetbeans && isNetbeansBuffer(buf))
3158 if (whole)
3161 * b_changed can be 0 after an undo, but we still need to write
3162 * the buffer to NetBeans.
3164 if (buf->b_changed || isNetbeansModified(buf))
3166 --no_wait_return; /* may wait for return now */
3167 msg_scroll = msg_save;
3168 netbeans_save_buffer(buf); /* no error checking... */
3169 return retval;
3171 else
3173 errnum = (char_u *)"E656: ";
3174 errmsg = (char_u *)_("NetBeans dissallows writes of unmodified buffers");
3175 buffer = NULL;
3176 goto fail;
3179 else
3181 errnum = (char_u *)"E657: ";
3182 errmsg = (char_u *)_("Partial writes disallowed for NetBeans buffers");
3183 buffer = NULL;
3184 goto fail;
3187 #endif
3189 if (shortmess(SHM_OVER) && !exiting)
3190 msg_scroll = FALSE; /* overwrite previous file message */
3191 else
3192 msg_scroll = TRUE; /* don't overwrite previous file message */
3193 if (!filtering)
3194 filemess(buf,
3195 #ifndef UNIX
3196 sfname,
3197 #else
3198 fname,
3199 #endif
3200 (char_u *)"", 0); /* show that we are busy */
3201 msg_scroll = FALSE; /* always overwrite the file message now */
3203 buffer = alloc(BUFSIZE);
3204 if (buffer == NULL) /* can't allocate big buffer, use small
3205 * one (to be able to write when out of
3206 * memory) */
3208 buffer = smallbuf;
3209 bufsize = SMBUFSIZE;
3211 else
3212 bufsize = BUFSIZE;
3215 * Get information about original file (if there is one).
3217 #if defined(UNIX) && !defined(ARCHIE)
3218 st_old.st_dev = 0;
3219 st_old.st_ino = 0;
3220 perm = -1;
3221 if (mch_stat((char *)fname, &st_old) < 0)
3222 newfile = TRUE;
3223 else
3225 perm = st_old.st_mode;
3226 if (!S_ISREG(st_old.st_mode)) /* not a file */
3228 if (S_ISDIR(st_old.st_mode))
3230 errnum = (char_u *)"E502: ";
3231 errmsg = (char_u *)_("is a directory");
3232 goto fail;
3234 if (mch_nodetype(fname) != NODE_WRITABLE)
3236 errnum = (char_u *)"E503: ";
3237 errmsg = (char_u *)_("is not a file or writable device");
3238 goto fail;
3240 /* It's a device of some kind (or a fifo) which we can write to
3241 * but for which we can't make a backup. */
3242 device = TRUE;
3243 newfile = TRUE;
3244 perm = -1;
3247 #else /* !UNIX */
3249 * Check for a writable device name.
3251 c = mch_nodetype(fname);
3252 if (c == NODE_OTHER)
3254 errnum = (char_u *)"E503: ";
3255 errmsg = (char_u *)_("is not a file or writable device");
3256 goto fail;
3258 if (c == NODE_WRITABLE)
3260 # if defined(MSDOS) || defined(MSWIN) || defined(OS2)
3261 /* MS-Windows allows opening a device, but we will probably get stuck
3262 * trying to write to it. */
3263 if (!p_odev)
3265 errnum = (char_u *)"E796: ";
3266 errmsg = (char_u *)_("writing to device disabled with 'opendevice' option");
3267 goto fail;
3269 # endif
3270 device = TRUE;
3271 newfile = TRUE;
3272 perm = -1;
3274 else
3276 perm = mch_getperm(fname);
3277 if (perm < 0)
3278 newfile = TRUE;
3279 else if (mch_isdir(fname))
3281 errnum = (char_u *)"E502: ";
3282 errmsg = (char_u *)_("is a directory");
3283 goto fail;
3285 if (overwriting)
3286 (void)mch_stat((char *)fname, &st_old);
3288 #endif /* !UNIX */
3290 if (!device && !newfile)
3293 * Check if the file is really writable (when renaming the file to
3294 * make a backup we won't discover it later).
3296 file_readonly = check_file_readonly(fname, (int)perm);
3298 if (!forceit && file_readonly)
3300 if (vim_strchr(p_cpo, CPO_FWRITE) != NULL)
3302 errnum = (char_u *)"E504: ";
3303 errmsg = (char_u *)_(err_readonly);
3305 else
3307 errnum = (char_u *)"E505: ";
3308 errmsg = (char_u *)_("is read-only (add ! to override)");
3310 goto fail;
3314 * Check if the timestamp hasn't changed since reading the file.
3316 if (overwriting)
3318 retval = check_mtime(buf, &st_old);
3319 if (retval == FAIL)
3320 goto fail;
3324 #ifdef HAVE_ACL
3326 * For systems that support ACL: get the ACL from the original file.
3328 if (!newfile)
3329 acl = mch_get_acl(fname);
3330 #endif
3333 * If 'backupskip' is not empty, don't make a backup for some files.
3335 dobackup = (p_wb || p_bk || *p_pm != NUL);
3336 #ifdef FEAT_WILDIGN
3337 if (dobackup && *p_bsk != NUL && match_file_list(p_bsk, sfname, ffname))
3338 dobackup = FALSE;
3339 #endif
3342 * Save the value of got_int and reset it. We don't want a previous
3343 * interruption cancel writing, only hitting CTRL-C while writing should
3344 * abort it.
3346 prev_got_int = got_int;
3347 got_int = FALSE;
3349 /* Mark the buffer as 'being saved' to prevent changed buffer warnings */
3350 buf->b_saving = TRUE;
3353 * If we are not appending or filtering, the file exists, and the
3354 * 'writebackup', 'backup' or 'patchmode' option is set, need a backup.
3355 * When 'patchmode' is set also make a backup when appending.
3357 * Do not make any backup, if 'writebackup' and 'backup' are both switched
3358 * off. This helps when editing large files on almost-full disks.
3360 if (!(append && *p_pm == NUL) && !filtering && perm >= 0 && dobackup)
3362 #if defined(UNIX) || defined(WIN32)
3363 struct stat st;
3364 #endif
3366 if ((bkc_flags & BKC_YES) || append) /* "yes" */
3367 backup_copy = TRUE;
3368 #if defined(UNIX) || defined(WIN32)
3369 else if ((bkc_flags & BKC_AUTO)) /* "auto" */
3371 int i;
3373 # ifdef UNIX
3375 * Don't rename the file when:
3376 * - it's a hard link
3377 * - it's a symbolic link
3378 * - we don't have write permission in the directory
3379 * - we can't set the owner/group of the new file
3381 if (st_old.st_nlink > 1
3382 || mch_lstat((char *)fname, &st) < 0
3383 || st.st_dev != st_old.st_dev
3384 || st.st_ino != st_old.st_ino
3385 # ifndef HAVE_FCHOWN
3386 || st.st_uid != st_old.st_uid
3387 || st.st_gid != st_old.st_gid
3388 # endif
3390 backup_copy = TRUE;
3391 else
3392 # else
3393 # ifdef WIN32
3394 /* On NTFS file systems hard links are possible. */
3395 if (mch_is_linked(fname))
3396 backup_copy = TRUE;
3397 else
3398 # endif
3399 # endif
3402 * Check if we can create a file and set the owner/group to
3403 * the ones from the original file.
3404 * First find a file name that doesn't exist yet (use some
3405 * arbitrary numbers).
3407 STRCPY(IObuff, fname);
3408 for (i = 4913; ; i += 123)
3410 sprintf((char *)gettail(IObuff), "%d", i);
3411 if (mch_lstat((char *)IObuff, &st) < 0)
3412 break;
3414 fd = mch_open((char *)IObuff,
3415 O_CREAT|O_WRONLY|O_EXCL|O_NOFOLLOW, perm);
3416 if (fd < 0) /* can't write in directory */
3417 backup_copy = TRUE;
3418 else
3420 # ifdef UNIX
3421 # ifdef HAVE_FCHOWN
3422 fchown(fd, st_old.st_uid, st_old.st_gid);
3423 # endif
3424 if (mch_stat((char *)IObuff, &st) < 0
3425 || st.st_uid != st_old.st_uid
3426 || st.st_gid != st_old.st_gid
3427 || st.st_mode != perm)
3428 backup_copy = TRUE;
3429 # endif
3430 /* Close the file before removing it, on MS-Windows we
3431 * can't delete an open file. */
3432 close(fd);
3433 mch_remove(IObuff);
3438 # ifdef UNIX
3440 * Break symlinks and/or hardlinks if we've been asked to.
3442 if ((bkc_flags & BKC_BREAKSYMLINK) || (bkc_flags & BKC_BREAKHARDLINK))
3444 int lstat_res;
3446 lstat_res = mch_lstat((char *)fname, &st);
3448 /* Symlinks. */
3449 if ((bkc_flags & BKC_BREAKSYMLINK)
3450 && lstat_res == 0
3451 && st.st_ino != st_old.st_ino)
3452 backup_copy = FALSE;
3454 /* Hardlinks. */
3455 if ((bkc_flags & BKC_BREAKHARDLINK)
3456 && st_old.st_nlink > 1
3457 && (lstat_res != 0 || st.st_ino == st_old.st_ino))
3458 backup_copy = FALSE;
3460 #endif
3462 #endif
3464 /* make sure we have a valid backup extension to use */
3465 if (*p_bex == NUL)
3467 #ifdef RISCOS
3468 backup_ext = (char_u *)"/bak";
3469 #else
3470 backup_ext = (char_u *)".bak";
3471 #endif
3473 else
3474 backup_ext = p_bex;
3476 if (backup_copy
3477 && (fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0)) >= 0)
3479 int bfd;
3480 char_u *copybuf, *wp;
3481 int some_error = FALSE;
3482 struct stat st_new;
3483 char_u *dirp;
3484 char_u *rootname;
3485 #if defined(UNIX) && !defined(SHORT_FNAME)
3486 int did_set_shortname;
3487 #endif
3489 copybuf = alloc(BUFSIZE + 1);
3490 if (copybuf == NULL)
3492 some_error = TRUE; /* out of memory */
3493 goto nobackup;
3497 * Try to make the backup in each directory in the 'bdir' option.
3499 * Unix semantics has it, that we may have a writable file,
3500 * that cannot be recreated with a simple open(..., O_CREAT, ) e.g:
3501 * - the directory is not writable,
3502 * - the file may be a symbolic link,
3503 * - the file may belong to another user/group, etc.
3505 * For these reasons, the existing writable file must be truncated
3506 * and reused. Creation of a backup COPY will be attempted.
3508 dirp = p_bdir;
3509 while (*dirp)
3511 #ifdef UNIX
3512 st_new.st_ino = 0;
3513 st_new.st_dev = 0;
3514 st_new.st_gid = 0;
3515 #endif
3518 * Isolate one directory name, using an entry in 'bdir'.
3520 (void)copy_option_part(&dirp, copybuf, BUFSIZE, ",");
3521 rootname = get_file_in_dir(fname, copybuf);
3522 if (rootname == NULL)
3524 some_error = TRUE; /* out of memory */
3525 goto nobackup;
3528 #if defined(UNIX) && !defined(SHORT_FNAME)
3529 did_set_shortname = FALSE;
3530 #endif
3533 * May try twice if 'shortname' not set.
3535 for (;;)
3538 * Make backup file name.
3540 backup = buf_modname(
3541 #ifdef SHORT_FNAME
3542 TRUE,
3543 #else
3544 (buf->b_p_sn || buf->b_shortname),
3545 #endif
3546 rootname, backup_ext, FALSE);
3547 if (backup == NULL)
3549 vim_free(rootname);
3550 some_error = TRUE; /* out of memory */
3551 goto nobackup;
3555 * Check if backup file already exists.
3557 if (mch_stat((char *)backup, &st_new) >= 0)
3559 #ifdef UNIX
3561 * Check if backup file is same as original file.
3562 * May happen when modname() gave the same file back.
3563 * E.g. silly link, or file name-length reached.
3564 * If we don't check here, we either ruin the file
3565 * when copying or erase it after writing. jw.
3567 if (st_new.st_dev == st_old.st_dev
3568 && st_new.st_ino == st_old.st_ino)
3570 vim_free(backup);
3571 backup = NULL; /* no backup file to delete */
3572 # ifndef SHORT_FNAME
3574 * may try again with 'shortname' set
3576 if (!(buf->b_shortname || buf->b_p_sn))
3578 buf->b_shortname = TRUE;
3579 did_set_shortname = TRUE;
3580 continue;
3582 /* setting shortname didn't help */
3583 if (did_set_shortname)
3584 buf->b_shortname = FALSE;
3585 # endif
3586 break;
3588 #endif
3591 * If we are not going to keep the backup file, don't
3592 * delete an existing one, try to use another name.
3593 * Change one character, just before the extension.
3595 if (!p_bk)
3597 wp = backup + STRLEN(backup) - 1
3598 - STRLEN(backup_ext);
3599 if (wp < backup) /* empty file name ??? */
3600 wp = backup;
3601 *wp = 'z';
3602 while (*wp > 'a'
3603 && mch_stat((char *)backup, &st_new) >= 0)
3604 --*wp;
3605 /* They all exist??? Must be something wrong. */
3606 if (*wp == 'a')
3608 vim_free(backup);
3609 backup = NULL;
3613 break;
3615 vim_free(rootname);
3618 * Try to create the backup file
3620 if (backup != NULL)
3622 /* remove old backup, if present */
3623 mch_remove(backup);
3624 /* Open with O_EXCL to avoid the file being created while
3625 * we were sleeping (symlink hacker attack?) */
3626 bfd = mch_open((char *)backup,
3627 O_WRONLY|O_CREAT|O_EXTRA|O_EXCL|O_NOFOLLOW,
3628 perm & 0777);
3629 if (bfd < 0)
3631 vim_free(backup);
3632 backup = NULL;
3634 else
3636 /* set file protection same as original file, but
3637 * strip s-bit */
3638 (void)mch_setperm(backup, perm & 0777);
3640 #ifdef UNIX
3642 * Try to set the group of the backup same as the
3643 * original file. If this fails, set the protection
3644 * bits for the group same as the protection bits for
3645 * others.
3647 if (st_new.st_gid != st_old.st_gid
3648 # ifdef HAVE_FCHOWN /* sequent-ptx lacks fchown() */
3649 && fchown(bfd, (uid_t)-1, st_old.st_gid) != 0
3650 # endif
3652 mch_setperm(backup,
3653 (perm & 0707) | ((perm & 07) << 3));
3654 # ifdef HAVE_SELINUX
3655 mch_copy_sec(fname, backup);
3656 # endif
3657 #endif
3660 * copy the file.
3662 write_info.bw_fd = bfd;
3663 write_info.bw_buf = copybuf;
3664 #ifdef HAS_BW_FLAGS
3665 write_info.bw_flags = FIO_NOCONVERT;
3666 #endif
3667 while ((write_info.bw_len = vim_read(fd, copybuf,
3668 BUFSIZE)) > 0)
3670 if (buf_write_bytes(&write_info) == FAIL)
3672 errmsg = (char_u *)_("E506: Can't write to backup file (add ! to override)");
3673 break;
3675 ui_breakcheck();
3676 if (got_int)
3678 errmsg = (char_u *)_(e_interr);
3679 break;
3683 if (close(bfd) < 0 && errmsg == NULL)
3684 errmsg = (char_u *)_("E507: Close error for backup file (add ! to override)");
3685 if (write_info.bw_len < 0)
3686 errmsg = (char_u *)_("E508: Can't read file for backup (add ! to override)");
3687 #ifdef UNIX
3688 set_file_time(backup, st_old.st_atime, st_old.st_mtime);
3689 #endif
3690 #ifdef HAVE_ACL
3691 mch_set_acl(backup, acl);
3692 #endif
3693 #ifdef HAVE_SELINUX
3694 mch_copy_sec(fname, backup);
3695 #endif
3696 break;
3700 nobackup:
3701 close(fd); /* ignore errors for closing read file */
3702 vim_free(copybuf);
3704 if (backup == NULL && errmsg == NULL)
3705 errmsg = (char_u *)_("E509: Cannot create backup file (add ! to override)");
3706 /* ignore errors when forceit is TRUE */
3707 if ((some_error || errmsg != NULL) && !forceit)
3709 retval = FAIL;
3710 goto fail;
3712 errmsg = NULL;
3714 else
3716 char_u *dirp;
3717 char_u *p;
3718 char_u *rootname;
3721 * Make a backup by renaming the original file.
3724 * If 'cpoptions' includes the "W" flag, we don't want to
3725 * overwrite a read-only file. But rename may be possible
3726 * anyway, thus we need an extra check here.
3728 if (file_readonly && vim_strchr(p_cpo, CPO_FWRITE) != NULL)
3730 errnum = (char_u *)"E504: ";
3731 errmsg = (char_u *)_(err_readonly);
3732 goto fail;
3737 * Form the backup file name - change path/fo.o.h to
3738 * path/fo.o.h.bak Try all directories in 'backupdir', first one
3739 * that works is used.
3741 dirp = p_bdir;
3742 while (*dirp)
3745 * Isolate one directory name and make the backup file name.
3747 (void)copy_option_part(&dirp, IObuff, IOSIZE, ",");
3748 rootname = get_file_in_dir(fname, IObuff);
3749 if (rootname == NULL)
3750 backup = NULL;
3751 else
3753 backup = buf_modname(
3754 #ifdef SHORT_FNAME
3755 TRUE,
3756 #else
3757 (buf->b_p_sn || buf->b_shortname),
3758 #endif
3759 rootname, backup_ext, FALSE);
3760 vim_free(rootname);
3763 if (backup != NULL)
3766 * If we are not going to keep the backup file, don't
3767 * delete an existing one, try to use another name.
3768 * Change one character, just before the extension.
3770 if (!p_bk && mch_getperm(backup) >= 0)
3772 p = backup + STRLEN(backup) - 1 - STRLEN(backup_ext);
3773 if (p < backup) /* empty file name ??? */
3774 p = backup;
3775 *p = 'z';
3776 while (*p > 'a' && mch_getperm(backup) >= 0)
3777 --*p;
3778 /* They all exist??? Must be something wrong! */
3779 if (*p == 'a')
3781 vim_free(backup);
3782 backup = NULL;
3786 if (backup != NULL)
3789 * Delete any existing backup and move the current version
3790 * to the backup. For safety, we don't remove the backup
3791 * until the write has finished successfully. And if the
3792 * 'backup' option is set, leave it around.
3795 * If the renaming of the original file to the backup file
3796 * works, quit here.
3798 if (vim_rename(fname, backup) == 0)
3799 break;
3801 vim_free(backup); /* don't do the rename below */
3802 backup = NULL;
3805 if (backup == NULL && !forceit)
3807 errmsg = (char_u *)_("E510: Can't make backup file (add ! to override)");
3808 goto fail;
3813 #if defined(UNIX) && !defined(ARCHIE)
3814 /* When using ":w!" and the file was read-only: make it writable */
3815 if (forceit && perm >= 0 && !(perm & 0200) && st_old.st_uid == getuid()
3816 && vim_strchr(p_cpo, CPO_FWRITE) == NULL)
3818 perm |= 0200;
3819 (void)mch_setperm(fname, perm);
3820 made_writable = TRUE;
3822 #endif
3824 /* When using ":w!" and writing to the current file, 'readonly' makes no
3825 * sense, reset it, unless 'Z' appears in 'cpoptions'. */
3826 if (forceit && overwriting && vim_strchr(p_cpo, CPO_KEEPRO) == NULL)
3828 buf->b_p_ro = FALSE;
3829 #ifdef FEAT_TITLE
3830 need_maketitle = TRUE; /* set window title later */
3831 #endif
3832 #ifdef FEAT_WINDOWS
3833 status_redraw_all(); /* redraw status lines later */
3834 #endif
3837 if (end > buf->b_ml.ml_line_count)
3838 end = buf->b_ml.ml_line_count;
3839 if (buf->b_ml.ml_flags & ML_EMPTY)
3840 start = end + 1;
3843 * If the original file is being overwritten, there is a small chance that
3844 * we crash in the middle of writing. Therefore the file is preserved now.
3845 * This makes all block numbers positive so that recovery does not need
3846 * the original file.
3847 * Don't do this if there is a backup file and we are exiting.
3849 if (reset_changed && !newfile && overwriting
3850 && !(exiting && backup != NULL))
3852 ml_preserve(buf, FALSE);
3853 if (got_int)
3855 errmsg = (char_u *)_(e_interr);
3856 goto restore_backup;
3860 #ifdef MACOS_CLASSIC /* TODO: Is it need for MACOS_X? (Dany) */
3862 * Before risking to lose the original file verify if there's
3863 * a resource fork to preserve, and if cannot be done warn
3864 * the users. This happens when overwriting without backups.
3866 if (backup == NULL && overwriting && !append)
3867 if (mch_has_resource_fork(fname))
3869 errmsg = (char_u *)_("E460: The resource fork would be lost (add ! to override)");
3870 goto restore_backup;
3872 #endif
3874 #ifdef VMS
3875 vms_remove_version(fname); /* remove version */
3876 #endif
3877 /* Default: write the the file directly. May write to a temp file for
3878 * multi-byte conversion. */
3879 wfname = fname;
3881 #ifdef FEAT_MBYTE
3882 /* Check for forced 'fileencoding' from "++opt=val" argument. */
3883 if (eap != NULL && eap->force_enc != 0)
3885 fenc = eap->cmd + eap->force_enc;
3886 fenc = enc_canonize(fenc);
3887 fenc_tofree = fenc;
3889 else
3890 fenc = buf->b_p_fenc;
3893 * The file needs to be converted when 'fileencoding' is set and
3894 * 'fileencoding' differs from 'encoding'.
3896 converted = (*fenc != NUL && !same_encoding(p_enc, fenc));
3899 * Check if UTF-8 to UCS-2/4 or Latin1 conversion needs to be done. Or
3900 * Latin1 to Unicode conversion. This is handled in buf_write_bytes().
3901 * Prepare the flags for it and allocate bw_conv_buf when needed.
3903 if (converted && (enc_utf8 || STRCMP(p_enc, "latin1") == 0))
3905 wb_flags = get_fio_flags(fenc);
3906 if (wb_flags & (FIO_UCS2 | FIO_UCS4 | FIO_UTF16 | FIO_UTF8))
3908 /* Need to allocate a buffer to translate into. */
3909 if (wb_flags & (FIO_UCS2 | FIO_UTF16 | FIO_UTF8))
3910 write_info.bw_conv_buflen = bufsize * 2;
3911 else /* FIO_UCS4 */
3912 write_info.bw_conv_buflen = bufsize * 4;
3913 write_info.bw_conv_buf
3914 = lalloc((long_u)write_info.bw_conv_buflen, TRUE);
3915 if (write_info.bw_conv_buf == NULL)
3916 end = 0;
3920 # ifdef WIN3264
3921 if (converted && wb_flags == 0 && (wb_flags = get_win_fio_flags(fenc)) != 0)
3923 /* Convert UTF-8 -> UCS-2 and UCS-2 -> DBCS. Worst-case * 4: */
3924 write_info.bw_conv_buflen = bufsize * 4;
3925 write_info.bw_conv_buf
3926 = lalloc((long_u)write_info.bw_conv_buflen, TRUE);
3927 if (write_info.bw_conv_buf == NULL)
3928 end = 0;
3930 # endif
3932 # ifdef MACOS_X
3933 if (converted && wb_flags == 0 && (wb_flags = get_mac_fio_flags(fenc)) != 0)
3935 write_info.bw_conv_buflen = bufsize * 3;
3936 write_info.bw_conv_buf
3937 = lalloc((long_u)write_info.bw_conv_buflen, TRUE);
3938 if (write_info.bw_conv_buf == NULL)
3939 end = 0;
3941 # endif
3943 # if defined(FEAT_EVAL) || defined(USE_ICONV)
3944 if (converted && wb_flags == 0)
3946 # ifdef USE_ICONV
3948 * Use iconv() conversion when conversion is needed and it's not done
3949 * internally.
3951 write_info.bw_iconv_fd = (iconv_t)my_iconv_open(fenc,
3952 enc_utf8 ? (char_u *)"utf-8" : p_enc);
3953 if (write_info.bw_iconv_fd != (iconv_t)-1)
3955 /* We're going to use iconv(), allocate a buffer to convert in. */
3956 write_info.bw_conv_buflen = bufsize * ICONV_MULT;
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 write_info.bw_first = TRUE;
3963 # ifdef FEAT_EVAL
3964 else
3965 # endif
3966 # endif
3968 # ifdef FEAT_EVAL
3970 * When the file needs to be converted with 'charconvert' after
3971 * writing, write to a temp file instead and let the conversion
3972 * overwrite the original file.
3974 if (*p_ccv != NUL)
3976 wfname = vim_tempname('w');
3977 if (wfname == NULL) /* Can't write without a tempfile! */
3979 errmsg = (char_u *)_("E214: Can't find temp file for writing");
3980 goto restore_backup;
3983 # endif
3985 # endif
3986 if (converted && wb_flags == 0
3987 # ifdef USE_ICONV
3988 && write_info.bw_iconv_fd == (iconv_t)-1
3989 # endif
3990 # ifdef FEAT_EVAL
3991 && wfname == fname
3992 # endif
3995 if (!forceit)
3997 errmsg = (char_u *)_("E213: Cannot convert (add ! to write without conversion)");
3998 goto restore_backup;
4000 notconverted = TRUE;
4002 #endif
4005 * Open the file "wfname" for writing.
4006 * We may try to open the file twice: If we can't write to the
4007 * file and forceit is TRUE we delete the existing file and try to create
4008 * a new one. If this still fails we may have lost the original file!
4009 * (this may happen when the user reached his quotum for number of files).
4010 * Appending will fail if the file does not exist and forceit is FALSE.
4012 while ((fd = mch_open((char *)wfname, O_WRONLY | O_EXTRA | (append
4013 ? (forceit ? (O_APPEND | O_CREAT) : O_APPEND)
4014 : (O_CREAT | O_TRUNC))
4015 , perm < 0 ? 0666 : (perm & 0777))) < 0)
4018 * A forced write will try to create a new file if the old one is
4019 * still readonly. This may also happen when the directory is
4020 * read-only. In that case the mch_remove() will fail.
4022 if (errmsg == NULL)
4024 #ifdef UNIX
4025 struct stat st;
4027 /* Don't delete the file when it's a hard or symbolic link. */
4028 if ((!newfile && st_old.st_nlink > 1)
4029 || (mch_lstat((char *)fname, &st) == 0
4030 && (st.st_dev != st_old.st_dev
4031 || st.st_ino != st_old.st_ino)))
4032 errmsg = (char_u *)_("E166: Can't open linked file for writing");
4033 else
4034 #endif
4036 errmsg = (char_u *)_("E212: Can't open file for writing");
4037 if (forceit && vim_strchr(p_cpo, CPO_FWRITE) == NULL
4038 && perm >= 0)
4040 #ifdef UNIX
4041 /* we write to the file, thus it should be marked
4042 writable after all */
4043 if (!(perm & 0200))
4044 made_writable = TRUE;
4045 perm |= 0200;
4046 if (st_old.st_uid != getuid() || st_old.st_gid != getgid())
4047 perm &= 0777;
4048 #endif
4049 if (!append) /* don't remove when appending */
4050 mch_remove(wfname);
4051 continue;
4056 restore_backup:
4058 struct stat st;
4061 * If we failed to open the file, we don't need a backup. Throw it
4062 * away. If we moved or removed the original file try to put the
4063 * backup in its place.
4065 if (backup != NULL && wfname == fname)
4067 if (backup_copy)
4070 * There is a small chance that we removed the original,
4071 * try to move the copy in its place.
4072 * This may not work if the vim_rename() fails.
4073 * In that case we leave the copy around.
4075 /* If file does not exist, put the copy in its place */
4076 if (mch_stat((char *)fname, &st) < 0)
4077 vim_rename(backup, fname);
4078 /* if original file does exist throw away the copy */
4079 if (mch_stat((char *)fname, &st) >= 0)
4080 mch_remove(backup);
4082 else
4084 /* try to put the original file back */
4085 vim_rename(backup, fname);
4089 /* if original file no longer exists give an extra warning */
4090 if (!newfile && mch_stat((char *)fname, &st) < 0)
4091 end = 0;
4094 #ifdef FEAT_MBYTE
4095 if (wfname != fname)
4096 vim_free(wfname);
4097 #endif
4098 goto fail;
4100 errmsg = NULL;
4102 #if defined(MACOS_CLASSIC) || defined(WIN3264)
4103 /* TODO: Is it need for MACOS_X? (Dany) */
4105 * On macintosh copy the original files attributes (i.e. the backup)
4106 * This is done in order to preserve the resource fork and the
4107 * Finder attribute (label, comments, custom icons, file creator)
4109 if (backup != NULL && overwriting && !append)
4111 if (backup_copy)
4112 (void)mch_copy_file_attribute(wfname, backup);
4113 else
4114 (void)mch_copy_file_attribute(backup, wfname);
4117 if (!overwriting && !append)
4119 if (buf->b_ffname != NULL)
4120 (void)mch_copy_file_attribute(buf->b_ffname, wfname);
4121 /* Should copy resource fork */
4123 #endif
4125 write_info.bw_fd = fd;
4127 #ifdef FEAT_CRYPT
4128 if (*buf->b_p_key && !filtering)
4130 crypt_init_keys(buf->b_p_key);
4131 /* Write magic number, so that Vim knows that this file is encrypted
4132 * when reading it again. This also undergoes utf-8 to ucs-2/4
4133 * conversion when needed. */
4134 write_info.bw_buf = (char_u *)CRYPT_MAGIC;
4135 write_info.bw_len = CRYPT_MAGIC_LEN;
4136 write_info.bw_flags = FIO_NOCONVERT;
4137 if (buf_write_bytes(&write_info) == FAIL)
4138 end = 0;
4139 wb_flags |= FIO_ENCRYPTED;
4141 #endif
4143 write_info.bw_buf = buffer;
4144 nchars = 0;
4146 /* use "++bin", "++nobin" or 'binary' */
4147 if (eap != NULL && eap->force_bin != 0)
4148 write_bin = (eap->force_bin == FORCE_BIN);
4149 else
4150 write_bin = buf->b_p_bin;
4152 #ifdef FEAT_MBYTE
4154 * The BOM is written just after the encryption magic number.
4155 * Skip it when appending and the file already existed, the BOM only makes
4156 * sense at the start of the file.
4158 if (buf->b_p_bomb && !write_bin && (!append || perm < 0))
4160 write_info.bw_len = make_bom(buffer, fenc);
4161 if (write_info.bw_len > 0)
4163 /* don't convert, do encryption */
4164 write_info.bw_flags = FIO_NOCONVERT | wb_flags;
4165 if (buf_write_bytes(&write_info) == FAIL)
4166 end = 0;
4167 else
4168 nchars += write_info.bw_len;
4171 #endif
4173 write_info.bw_len = bufsize;
4174 #ifdef HAS_BW_FLAGS
4175 write_info.bw_flags = wb_flags;
4176 #endif
4177 fileformat = get_fileformat_force(buf, eap);
4178 s = buffer;
4179 len = 0;
4180 for (lnum = start; lnum <= end; ++lnum)
4183 * The next while loop is done once for each character written.
4184 * Keep it fast!
4186 ptr = ml_get_buf(buf, lnum, FALSE) - 1;
4187 while ((c = *++ptr) != NUL)
4189 if (c == NL)
4190 *s = NUL; /* replace newlines with NULs */
4191 else if (c == CAR && fileformat == EOL_MAC)
4192 *s = NL; /* Mac: replace CRs with NLs */
4193 else
4194 *s = c;
4195 ++s;
4196 if (++len != bufsize)
4197 continue;
4198 if (buf_write_bytes(&write_info) == FAIL)
4200 end = 0; /* write error: break loop */
4201 break;
4203 nchars += bufsize;
4204 s = buffer;
4205 len = 0;
4207 /* write failed or last line has no EOL: stop here */
4208 if (end == 0
4209 || (lnum == end
4210 && write_bin
4211 && (lnum == write_no_eol_lnum
4212 || (lnum == buf->b_ml.ml_line_count && !buf->b_p_eol))))
4214 ++lnum; /* written the line, count it */
4215 no_eol = TRUE;
4216 break;
4218 if (fileformat == EOL_UNIX)
4219 *s++ = NL;
4220 else
4222 *s++ = CAR; /* EOL_MAC or EOL_DOS: write CR */
4223 if (fileformat == EOL_DOS) /* write CR-NL */
4225 if (++len == bufsize)
4227 if (buf_write_bytes(&write_info) == FAIL)
4229 end = 0; /* write error: break loop */
4230 break;
4232 nchars += bufsize;
4233 s = buffer;
4234 len = 0;
4236 *s++ = NL;
4239 if (++len == bufsize && end)
4241 if (buf_write_bytes(&write_info) == FAIL)
4243 end = 0; /* write error: break loop */
4244 break;
4246 nchars += bufsize;
4247 s = buffer;
4248 len = 0;
4250 ui_breakcheck();
4251 if (got_int)
4253 end = 0; /* Interrupted, break loop */
4254 break;
4257 #ifdef VMS
4259 * On VMS there is a problem: newlines get added when writing blocks
4260 * at a time. Fix it by writing a line at a time.
4261 * This is much slower!
4262 * Explanation: VAX/DECC RTL insists that records in some RMS
4263 * structures end with a newline (carriage return) character, and if
4264 * they don't it adds one.
4265 * With other RMS structures it works perfect without this fix.
4267 if (buf->b_fab_rfm == FAB$C_VFC
4268 || ((buf->b_fab_rat & (FAB$M_FTN | FAB$M_CR)) != 0))
4270 int b2write;
4272 buf->b_fab_mrs = (buf->b_fab_mrs == 0
4273 ? MIN(4096, bufsize)
4274 : MIN(buf->b_fab_mrs, bufsize));
4276 b2write = len;
4277 while (b2write > 0)
4279 write_info.bw_len = MIN(b2write, buf->b_fab_mrs);
4280 if (buf_write_bytes(&write_info) == FAIL)
4282 end = 0;
4283 break;
4285 b2write -= MIN(b2write, buf->b_fab_mrs);
4287 write_info.bw_len = bufsize;
4288 nchars += len;
4289 s = buffer;
4290 len = 0;
4292 #endif
4294 if (len > 0 && end > 0)
4296 write_info.bw_len = len;
4297 if (buf_write_bytes(&write_info) == FAIL)
4298 end = 0; /* write error */
4299 nchars += len;
4302 #if defined(UNIX) && defined(HAVE_FSYNC)
4303 /* On many journalling file systems there is a bug that causes both the
4304 * original and the backup file to be lost when halting the system right
4305 * after writing the file. That's because only the meta-data is
4306 * journalled. Syncing the file slows down the system, but assures it has
4307 * been written to disk and we don't lose it.
4308 * For a device do try the fsync() but don't complain if it does not work
4309 * (could be a pipe).
4310 * If the 'fsync' option is FALSE, don't fsync(). Useful for laptops. */
4311 if (p_fs && fsync(fd) != 0 && !device)
4313 errmsg = (char_u *)_("E667: Fsync failed");
4314 end = 0;
4316 #endif
4318 #ifdef HAVE_SELINUX
4319 /* Probably need to set the security context. */
4320 if (!backup_copy)
4321 mch_copy_sec(backup, wfname);
4322 #endif
4324 #ifdef UNIX
4325 /* When creating a new file, set its owner/group to that of the original
4326 * file. Get the new device and inode number. */
4327 if (backup != NULL && !backup_copy)
4329 # ifdef HAVE_FCHOWN
4330 struct stat st;
4332 /* don't change the owner when it's already OK, some systems remove
4333 * permission or ACL stuff */
4334 if (mch_stat((char *)wfname, &st) < 0
4335 || st.st_uid != st_old.st_uid
4336 || st.st_gid != st_old.st_gid)
4338 fchown(fd, st_old.st_uid, st_old.st_gid);
4339 if (perm >= 0) /* set permission again, may have changed */
4340 (void)mch_setperm(wfname, perm);
4342 # endif
4343 buf_setino(buf);
4345 else if (buf->b_dev < 0)
4346 /* Set the inode when creating a new file. */
4347 buf_setino(buf);
4348 #endif
4350 if (close(fd) != 0)
4352 errmsg = (char_u *)_("E512: Close failed");
4353 end = 0;
4356 #ifdef UNIX
4357 if (made_writable)
4358 perm &= ~0200; /* reset 'w' bit for security reasons */
4359 #endif
4360 if (perm >= 0) /* set perm. of new file same as old file */
4361 (void)mch_setperm(wfname, perm);
4362 #ifdef RISCOS
4363 if (!append && !filtering)
4364 /* Set the filetype after writing the file. */
4365 mch_set_filetype(wfname, buf->b_p_oft);
4366 #endif
4367 #ifdef HAVE_ACL
4368 /* Probably need to set the ACL before changing the user (can't set the
4369 * ACL on a file the user doesn't own). */
4370 if (!backup_copy)
4371 mch_set_acl(wfname, acl);
4372 #endif
4375 #if defined(FEAT_MBYTE) && defined(FEAT_EVAL)
4376 if (wfname != fname)
4379 * The file was written to a temp file, now it needs to be converted
4380 * with 'charconvert' to (overwrite) the output file.
4382 if (end != 0)
4384 if (eval_charconvert(enc_utf8 ? (char_u *)"utf-8" : p_enc, fenc,
4385 wfname, fname) == FAIL)
4387 write_info.bw_conv_error = TRUE;
4388 end = 0;
4391 mch_remove(wfname);
4392 vim_free(wfname);
4394 #endif
4396 if (end == 0)
4398 if (errmsg == NULL)
4400 #ifdef FEAT_MBYTE
4401 if (write_info.bw_conv_error)
4402 errmsg = (char_u *)_("E513: write error, conversion failed (make 'fenc' empty to override)");
4403 else
4404 #endif
4405 if (got_int)
4406 errmsg = (char_u *)_(e_interr);
4407 else
4408 errmsg = (char_u *)_("E514: write error (file system full?)");
4412 * If we have a backup file, try to put it in place of the new file,
4413 * because the new file is probably corrupt. This avoids loosing the
4414 * original file when trying to make a backup when writing the file a
4415 * second time.
4416 * When "backup_copy" is set we need to copy the backup over the new
4417 * file. Otherwise rename the backup file.
4418 * If this is OK, don't give the extra warning message.
4420 if (backup != NULL)
4422 if (backup_copy)
4424 /* This may take a while, if we were interrupted let the user
4425 * know we got the message. */
4426 if (got_int)
4428 MSG(_(e_interr));
4429 out_flush();
4431 if ((fd = mch_open((char *)backup, O_RDONLY | O_EXTRA, 0)) >= 0)
4433 if ((write_info.bw_fd = mch_open((char *)fname,
4434 O_WRONLY | O_CREAT | O_TRUNC | O_EXTRA,
4435 perm & 0777)) >= 0)
4437 /* copy the file. */
4438 write_info.bw_buf = smallbuf;
4439 #ifdef HAS_BW_FLAGS
4440 write_info.bw_flags = FIO_NOCONVERT;
4441 #endif
4442 while ((write_info.bw_len = vim_read(fd, smallbuf,
4443 SMBUFSIZE)) > 0)
4444 if (buf_write_bytes(&write_info) == FAIL)
4445 break;
4447 if (close(write_info.bw_fd) >= 0
4448 && write_info.bw_len == 0)
4449 end = 1; /* success */
4451 close(fd); /* ignore errors for closing read file */
4454 else
4456 if (vim_rename(backup, fname) == 0)
4457 end = 1;
4460 goto fail;
4463 lnum -= start; /* compute number of written lines */
4464 --no_wait_return; /* may wait for return now */
4466 #if !(defined(UNIX) || defined(VMS))
4467 fname = sfname; /* use shortname now, for the messages */
4468 #endif
4469 if (!filtering)
4471 msg_add_fname(buf, fname); /* put fname in IObuff with quotes */
4472 c = FALSE;
4473 #ifdef FEAT_MBYTE
4474 if (write_info.bw_conv_error)
4476 STRCAT(IObuff, _(" CONVERSION ERROR"));
4477 c = TRUE;
4479 else if (notconverted)
4481 STRCAT(IObuff, _("[NOT converted]"));
4482 c = TRUE;
4484 else if (converted)
4486 STRCAT(IObuff, _("[converted]"));
4487 c = TRUE;
4489 #endif
4490 if (device)
4492 STRCAT(IObuff, _("[Device]"));
4493 c = TRUE;
4495 else if (newfile)
4497 STRCAT(IObuff, shortmess(SHM_NEW) ? _("[New]") : _("[New File]"));
4498 c = TRUE;
4500 if (no_eol)
4502 msg_add_eol();
4503 c = TRUE;
4505 /* may add [unix/dos/mac] */
4506 if (msg_add_fileformat(fileformat))
4507 c = TRUE;
4508 #ifdef FEAT_CRYPT
4509 if (wb_flags & FIO_ENCRYPTED)
4511 STRCAT(IObuff, _("[crypted]"));
4512 c = TRUE;
4514 #endif
4515 msg_add_lines(c, (long)lnum, nchars); /* add line/char count */
4516 if (!shortmess(SHM_WRITE))
4518 if (append)
4519 STRCAT(IObuff, shortmess(SHM_WRI) ? _(" [a]") : _(" appended"));
4520 else
4521 STRCAT(IObuff, shortmess(SHM_WRI) ? _(" [w]") : _(" written"));
4524 set_keep_msg(msg_trunc_attr(IObuff, FALSE, 0), 0);
4527 /* When written everything correctly: reset 'modified'. Unless not
4528 * writing to the original file and '+' is not in 'cpoptions'. */
4529 if (reset_changed && whole && !append
4530 #ifdef FEAT_MBYTE
4531 && !write_info.bw_conv_error
4532 #endif
4533 && (overwriting || vim_strchr(p_cpo, CPO_PLUS) != NULL)
4536 unchanged(buf, TRUE);
4537 u_unchanged(buf);
4541 * If written to the current file, update the timestamp of the swap file
4542 * and reset the BF_WRITE_MASK flags. Also sets buf->b_mtime.
4544 if (overwriting)
4546 ml_timestamp(buf);
4547 if (append)
4548 buf->b_flags &= ~BF_NEW;
4549 else
4550 buf->b_flags &= ~BF_WRITE_MASK;
4554 * If we kept a backup until now, and we are in patch mode, then we make
4555 * the backup file our 'original' file.
4557 if (*p_pm && dobackup)
4559 char *org = (char *)buf_modname(
4560 #ifdef SHORT_FNAME
4561 TRUE,
4562 #else
4563 (buf->b_p_sn || buf->b_shortname),
4564 #endif
4565 fname, p_pm, FALSE);
4567 if (backup != NULL)
4569 struct stat st;
4572 * If the original file does not exist yet
4573 * the current backup file becomes the original file
4575 if (org == NULL)
4576 EMSG(_("E205: Patchmode: can't save original file"));
4577 else if (mch_stat(org, &st) < 0)
4579 vim_rename(backup, (char_u *)org);
4580 vim_free(backup); /* don't delete the file */
4581 backup = NULL;
4582 #ifdef UNIX
4583 set_file_time((char_u *)org, st_old.st_atime, st_old.st_mtime);
4584 #endif
4588 * If there is no backup file, remember that a (new) file was
4589 * created.
4591 else
4593 int empty_fd;
4595 if (org == NULL
4596 || (empty_fd = mch_open(org,
4597 O_CREAT | O_EXTRA | O_EXCL | O_NOFOLLOW,
4598 perm < 0 ? 0666 : (perm & 0777))) < 0)
4599 EMSG(_("E206: patchmode: can't touch empty original file"));
4600 else
4601 close(empty_fd);
4603 if (org != NULL)
4605 mch_setperm((char_u *)org, mch_getperm(fname) & 0777);
4606 vim_free(org);
4611 * Remove the backup unless 'backup' option is set
4613 if (!p_bk && backup != NULL && mch_remove(backup) != 0)
4614 EMSG(_("E207: Can't delete backup file"));
4616 #ifdef FEAT_SUN_WORKSHOP
4617 if (usingSunWorkShop)
4618 workshop_file_saved((char *) ffname);
4619 #endif
4621 goto nofail;
4624 * Finish up. We get here either after failure or success.
4626 fail:
4627 --no_wait_return; /* may wait for return now */
4628 nofail:
4630 /* Done saving, we accept changed buffer warnings again */
4631 buf->b_saving = FALSE;
4633 vim_free(backup);
4634 if (buffer != smallbuf)
4635 vim_free(buffer);
4636 #ifdef FEAT_MBYTE
4637 vim_free(fenc_tofree);
4638 vim_free(write_info.bw_conv_buf);
4639 # ifdef USE_ICONV
4640 if (write_info.bw_iconv_fd != (iconv_t)-1)
4642 iconv_close(write_info.bw_iconv_fd);
4643 write_info.bw_iconv_fd = (iconv_t)-1;
4645 # endif
4646 #endif
4647 #ifdef HAVE_ACL
4648 mch_free_acl(acl);
4649 #endif
4651 if (errmsg != NULL)
4653 int numlen = errnum != NULL ? (int)STRLEN(errnum) : 0;
4655 attr = hl_attr(HLF_E); /* set highlight for error messages */
4656 msg_add_fname(buf,
4657 #ifndef UNIX
4658 sfname
4659 #else
4660 fname
4661 #endif
4662 ); /* put file name in IObuff with quotes */
4663 if (STRLEN(IObuff) + STRLEN(errmsg) + numlen >= IOSIZE)
4664 IObuff[IOSIZE - STRLEN(errmsg) - numlen - 1] = NUL;
4665 /* If the error message has the form "is ...", put the error number in
4666 * front of the file name. */
4667 if (errnum != NULL)
4669 mch_memmove(IObuff + numlen, IObuff, STRLEN(IObuff) + 1);
4670 mch_memmove(IObuff, errnum, (size_t)numlen);
4672 STRCAT(IObuff, errmsg);
4673 emsg(IObuff);
4675 retval = FAIL;
4676 if (end == 0)
4678 MSG_PUTS_ATTR(_("\nWARNING: Original file may be lost or damaged\n"),
4679 attr | MSG_HIST);
4680 MSG_PUTS_ATTR(_("don't quit the editor until the file is successfully written!"),
4681 attr | MSG_HIST);
4683 /* Update the timestamp to avoid an "overwrite changed file"
4684 * prompt when writing again. */
4685 if (mch_stat((char *)fname, &st_old) >= 0)
4687 buf_store_time(buf, &st_old, fname);
4688 buf->b_mtime_read = buf->b_mtime;
4692 msg_scroll = msg_save;
4694 #ifdef FEAT_AUTOCMD
4695 #ifdef FEAT_EVAL
4696 if (!should_abort(retval))
4697 #else
4698 if (!got_int)
4699 #endif
4701 aco_save_T aco;
4703 write_no_eol_lnum = 0; /* in case it was set by the previous read */
4706 * Apply POST autocommands.
4707 * Careful: The autocommands may call buf_write() recursively!
4709 aucmd_prepbuf(&aco, buf);
4711 if (append)
4712 apply_autocmds_exarg(EVENT_FILEAPPENDPOST, fname, fname,
4713 FALSE, curbuf, eap);
4714 else if (filtering)
4715 apply_autocmds_exarg(EVENT_FILTERWRITEPOST, NULL, fname,
4716 FALSE, curbuf, eap);
4717 else if (reset_changed && whole)
4718 apply_autocmds_exarg(EVENT_BUFWRITEPOST, fname, fname,
4719 FALSE, curbuf, eap);
4720 else
4721 apply_autocmds_exarg(EVENT_FILEWRITEPOST, fname, fname,
4722 FALSE, curbuf, eap);
4724 /* restore curwin/curbuf and a few other things */
4725 aucmd_restbuf(&aco);
4727 #ifdef FEAT_EVAL
4728 if (aborting()) /* autocmds may abort script processing */
4729 retval = FALSE;
4730 #endif
4732 #endif
4734 got_int |= prev_got_int;
4736 #ifdef MACOS_CLASSIC /* TODO: Is it need for MACOS_X? (Dany) */
4737 /* Update machine specific information. */
4738 mch_post_buffer_write(buf);
4739 #endif
4740 #ifdef FEAT_ODB_EDITOR
4741 odb_post_buffer_write(buf);
4742 #endif
4744 return retval;
4748 * Set the name of the current buffer. Use when the buffer doesn't have a
4749 * name and a ":r" or ":w" command with a file name is used.
4751 static int
4752 set_rw_fname(fname, sfname)
4753 char_u *fname;
4754 char_u *sfname;
4756 #ifdef FEAT_AUTOCMD
4757 /* It's like the unnamed buffer is deleted.... */
4758 if (curbuf->b_p_bl)
4759 apply_autocmds(EVENT_BUFDELETE, NULL, NULL, FALSE, curbuf);
4760 apply_autocmds(EVENT_BUFWIPEOUT, NULL, NULL, FALSE, curbuf);
4761 # ifdef FEAT_EVAL
4762 if (aborting()) /* autocmds may abort script processing */
4763 return FAIL;
4764 # endif
4765 #endif
4767 if (setfname(curbuf, fname, sfname, FALSE) == OK)
4768 curbuf->b_flags |= BF_NOTEDITED;
4770 #ifdef FEAT_AUTOCMD
4771 /* ....and a new named one is created */
4772 apply_autocmds(EVENT_BUFNEW, NULL, NULL, FALSE, curbuf);
4773 if (curbuf->b_p_bl)
4774 apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, curbuf);
4775 # ifdef FEAT_EVAL
4776 if (aborting()) /* autocmds may abort script processing */
4777 return FAIL;
4778 # endif
4780 /* Do filetype detection now if 'filetype' is empty. */
4781 if (*curbuf->b_p_ft == NUL)
4783 if (au_has_group((char_u *)"filetypedetect"))
4784 (void)do_doautocmd((char_u *)"filetypedetect BufRead", FALSE);
4785 do_modelines(0);
4787 #endif
4789 return OK;
4793 * Put file name into IObuff with quotes.
4795 void
4796 msg_add_fname(buf, fname)
4797 buf_T *buf;
4798 char_u *fname;
4800 if (fname == NULL)
4801 fname = (char_u *)"-stdin-";
4802 home_replace(buf, fname, IObuff + 1, IOSIZE - 4, TRUE);
4803 IObuff[0] = '"';
4804 STRCAT(IObuff, "\" ");
4808 * Append message for text mode to IObuff.
4809 * Return TRUE if something appended.
4811 static int
4812 msg_add_fileformat(eol_type)
4813 int eol_type;
4815 #ifndef USE_CRNL
4816 if (eol_type == EOL_DOS)
4818 STRCAT(IObuff, shortmess(SHM_TEXT) ? _("[dos]") : _("[dos format]"));
4819 return TRUE;
4821 #endif
4822 #ifndef USE_CR
4823 if (eol_type == EOL_MAC)
4825 STRCAT(IObuff, shortmess(SHM_TEXT) ? _("[mac]") : _("[mac format]"));
4826 return TRUE;
4828 #endif
4829 #if defined(USE_CRNL) || defined(USE_CR)
4830 if (eol_type == EOL_UNIX)
4832 STRCAT(IObuff, shortmess(SHM_TEXT) ? _("[unix]") : _("[unix format]"));
4833 return TRUE;
4835 #endif
4836 return FALSE;
4840 * Append line and character count to IObuff.
4842 void
4843 msg_add_lines(insert_space, lnum, nchars)
4844 int insert_space;
4845 long lnum;
4846 long nchars;
4848 char_u *p;
4850 p = IObuff + STRLEN(IObuff);
4852 if (insert_space)
4853 *p++ = ' ';
4854 if (shortmess(SHM_LINES))
4855 sprintf((char *)p, "%ldL, %ldC", lnum, nchars);
4856 else
4858 if (lnum == 1)
4859 STRCPY(p, _("1 line, "));
4860 else
4861 sprintf((char *)p, _("%ld lines, "), lnum);
4862 p += STRLEN(p);
4863 if (nchars == 1)
4864 STRCPY(p, _("1 character"));
4865 else
4866 sprintf((char *)p, _("%ld characters"), nchars);
4871 * Append message for missing line separator to IObuff.
4873 static void
4874 msg_add_eol()
4876 STRCAT(IObuff, shortmess(SHM_LAST) ? _("[noeol]") : _("[Incomplete last line]"));
4880 * Check modification time of file, before writing to it.
4881 * The size isn't checked, because using a tool like "gzip" takes care of
4882 * using the same timestamp but can't set the size.
4884 static int
4885 check_mtime(buf, st)
4886 buf_T *buf;
4887 struct stat *st;
4889 if (buf->b_mtime_read != 0
4890 && time_differs((long)st->st_mtime, buf->b_mtime_read))
4892 msg_scroll = TRUE; /* don't overwrite messages here */
4893 msg_silent = 0; /* must give this prompt */
4894 /* don't use emsg() here, don't want to flush the buffers */
4895 MSG_ATTR(_("WARNING: The file has been changed since reading it!!!"),
4896 hl_attr(HLF_E));
4897 if (ask_yesno((char_u *)_("Do you really want to write to it"),
4898 TRUE) == 'n')
4899 return FAIL;
4900 msg_scroll = FALSE; /* always overwrite the file message now */
4902 return OK;
4905 static int
4906 time_differs(t1, t2)
4907 long t1, t2;
4909 #if defined(__linux__) || defined(MSDOS) || defined(MSWIN)
4910 /* On a FAT filesystem, esp. under Linux, there are only 5 bits to store
4911 * the seconds. Since the roundoff is done when flushing the inode, the
4912 * time may change unexpectedly by one second!!! */
4913 return (t1 - t2 > 1 || t2 - t1 > 1);
4914 #else
4915 return (t1 != t2);
4916 #endif
4920 * Call write() to write a number of bytes to the file.
4921 * Also handles encryption and 'encoding' conversion.
4923 * Return FAIL for failure, OK otherwise.
4925 static int
4926 buf_write_bytes(ip)
4927 struct bw_info *ip;
4929 int wlen;
4930 char_u *buf = ip->bw_buf; /* data to write */
4931 int len = ip->bw_len; /* length of data */
4932 #ifdef HAS_BW_FLAGS
4933 int flags = ip->bw_flags; /* extra flags */
4934 #endif
4936 #ifdef FEAT_MBYTE
4938 * Skip conversion when writing the crypt magic number or the BOM.
4940 if (!(flags & FIO_NOCONVERT))
4942 char_u *p;
4943 unsigned c;
4944 int n;
4946 if (flags & FIO_UTF8)
4949 * Convert latin1 in the buffer to UTF-8 in the file.
4951 p = ip->bw_conv_buf; /* translate to buffer */
4952 for (wlen = 0; wlen < len; ++wlen)
4953 p += utf_char2bytes(buf[wlen], p);
4954 buf = ip->bw_conv_buf;
4955 len = (int)(p - ip->bw_conv_buf);
4957 else if (flags & (FIO_UCS4 | FIO_UTF16 | FIO_UCS2 | FIO_LATIN1))
4960 * Convert UTF-8 bytes in the buffer to UCS-2, UCS-4, UTF-16 or
4961 * Latin1 chars in the file.
4963 if (flags & FIO_LATIN1)
4964 p = buf; /* translate in-place (can only get shorter) */
4965 else
4966 p = ip->bw_conv_buf; /* translate to buffer */
4967 for (wlen = 0; wlen < len; wlen += n)
4969 if (wlen == 0 && ip->bw_restlen != 0)
4971 int l;
4973 /* Use remainder of previous call. Append the start of
4974 * buf[] to get a full sequence. Might still be too
4975 * short! */
4976 l = CONV_RESTLEN - ip->bw_restlen;
4977 if (l > len)
4978 l = len;
4979 mch_memmove(ip->bw_rest + ip->bw_restlen, buf, (size_t)l);
4980 n = utf_ptr2len_len(ip->bw_rest, ip->bw_restlen + l);
4981 if (n > ip->bw_restlen + len)
4983 /* We have an incomplete byte sequence at the end to
4984 * be written. We can't convert it without the
4985 * remaining bytes. Keep them for the next call. */
4986 if (ip->bw_restlen + len > CONV_RESTLEN)
4987 return FAIL;
4988 ip->bw_restlen += len;
4989 break;
4991 if (n > 1)
4992 c = utf_ptr2char(ip->bw_rest);
4993 else
4994 c = ip->bw_rest[0];
4995 if (n >= ip->bw_restlen)
4997 n -= ip->bw_restlen;
4998 ip->bw_restlen = 0;
5000 else
5002 ip->bw_restlen -= n;
5003 mch_memmove(ip->bw_rest, ip->bw_rest + n,
5004 (size_t)ip->bw_restlen);
5005 n = 0;
5008 else
5010 n = utf_ptr2len_len(buf + wlen, len - wlen);
5011 if (n > len - wlen)
5013 /* We have an incomplete byte sequence at the end to
5014 * be written. We can't convert it without the
5015 * remaining bytes. Keep them for the next call. */
5016 if (len - wlen > CONV_RESTLEN)
5017 return FAIL;
5018 ip->bw_restlen = len - wlen;
5019 mch_memmove(ip->bw_rest, buf + wlen,
5020 (size_t)ip->bw_restlen);
5021 break;
5023 if (n > 1)
5024 c = utf_ptr2char(buf + wlen);
5025 else
5026 c = buf[wlen];
5029 ip->bw_conv_error |= ucs2bytes(c, &p, flags);
5031 if (flags & FIO_LATIN1)
5032 len = (int)(p - buf);
5033 else
5035 buf = ip->bw_conv_buf;
5036 len = (int)(p - ip->bw_conv_buf);
5040 # ifdef WIN3264
5041 else if (flags & FIO_CODEPAGE)
5044 * Convert UTF-8 or codepage to UCS-2 and then to MS-Windows
5045 * codepage.
5047 char_u *from;
5048 size_t fromlen;
5049 char_u *to;
5050 int u8c;
5051 BOOL bad = FALSE;
5052 int needed;
5054 if (ip->bw_restlen > 0)
5056 /* Need to concatenate the remainder of the previous call and
5057 * the bytes of the current call. Use the end of the
5058 * conversion buffer for this. */
5059 fromlen = len + ip->bw_restlen;
5060 from = ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
5061 mch_memmove(from, ip->bw_rest, (size_t)ip->bw_restlen);
5062 mch_memmove(from + ip->bw_restlen, buf, (size_t)len);
5064 else
5066 from = buf;
5067 fromlen = len;
5070 to = ip->bw_conv_buf;
5071 if (enc_utf8)
5073 /* Convert from UTF-8 to UCS-2, to the start of the buffer.
5074 * The buffer has been allocated to be big enough. */
5075 while (fromlen > 0)
5077 n = (int)utf_ptr2len_len(from, (int)fromlen);
5078 if (n > (int)fromlen) /* incomplete byte sequence */
5079 break;
5080 u8c = utf_ptr2char(from);
5081 *to++ = (u8c & 0xff);
5082 *to++ = (u8c >> 8);
5083 fromlen -= n;
5084 from += n;
5087 /* Copy remainder to ip->bw_rest[] to be used for the next
5088 * call. */
5089 if (fromlen > CONV_RESTLEN)
5091 /* weird overlong sequence */
5092 ip->bw_conv_error = TRUE;
5093 return FAIL;
5095 mch_memmove(ip->bw_rest, from, fromlen);
5096 ip->bw_restlen = (int)fromlen;
5098 else
5100 /* Convert from enc_codepage to UCS-2, to the start of the
5101 * buffer. The buffer has been allocated to be big enough. */
5102 ip->bw_restlen = 0;
5103 needed = MultiByteToWideChar(enc_codepage,
5104 MB_ERR_INVALID_CHARS, (LPCSTR)from, (int)fromlen,
5105 NULL, 0);
5106 if (needed == 0)
5108 /* When conversion fails there may be a trailing byte. */
5109 needed = MultiByteToWideChar(enc_codepage,
5110 MB_ERR_INVALID_CHARS, (LPCSTR)from, (int)fromlen - 1,
5111 NULL, 0);
5112 if (needed == 0)
5114 /* Conversion doesn't work. */
5115 ip->bw_conv_error = TRUE;
5116 return FAIL;
5118 /* Save the trailing byte for the next call. */
5119 ip->bw_rest[0] = from[fromlen - 1];
5120 ip->bw_restlen = 1;
5122 needed = MultiByteToWideChar(enc_codepage, MB_ERR_INVALID_CHARS,
5123 (LPCSTR)from, (int)(fromlen - ip->bw_restlen),
5124 (LPWSTR)to, needed);
5125 if (needed == 0)
5127 /* Safety check: Conversion doesn't work. */
5128 ip->bw_conv_error = TRUE;
5129 return FAIL;
5131 to += needed * 2;
5134 fromlen = to - ip->bw_conv_buf;
5135 buf = to;
5136 # ifdef CP_UTF8 /* VC 4.1 doesn't define CP_UTF8 */
5137 if (FIO_GET_CP(flags) == CP_UTF8)
5139 /* Convert from UCS-2 to UTF-8, using the remainder of the
5140 * conversion buffer. Fails when out of space. */
5141 for (from = ip->bw_conv_buf; fromlen > 1; fromlen -= 2)
5143 u8c = *from++;
5144 u8c += (*from++ << 8);
5145 to += utf_char2bytes(u8c, to);
5146 if (to + 6 >= ip->bw_conv_buf + ip->bw_conv_buflen)
5148 ip->bw_conv_error = TRUE;
5149 return FAIL;
5152 len = (int)(to - buf);
5154 else
5155 #endif
5157 /* Convert from UCS-2 to the codepage, using the remainder of
5158 * the conversion buffer. If the conversion uses the default
5159 * character "0", the data doesn't fit in this encoding, so
5160 * fail. */
5161 len = WideCharToMultiByte(FIO_GET_CP(flags), 0,
5162 (LPCWSTR)ip->bw_conv_buf, (int)fromlen / sizeof(WCHAR),
5163 (LPSTR)to, (int)(ip->bw_conv_buflen - fromlen), 0,
5164 &bad);
5165 if (bad)
5167 ip->bw_conv_error = TRUE;
5168 return FAIL;
5172 # endif
5174 # ifdef MACOS_CONVERT
5175 else if (flags & FIO_MACROMAN)
5178 * Convert UTF-8 or latin1 to Apple MacRoman.
5180 char_u *from;
5181 size_t fromlen;
5183 if (ip->bw_restlen > 0)
5185 /* Need to concatenate the remainder of the previous call and
5186 * the bytes of the current call. Use the end of the
5187 * conversion buffer for this. */
5188 fromlen = len + ip->bw_restlen;
5189 from = ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
5190 mch_memmove(from, ip->bw_rest, (size_t)ip->bw_restlen);
5191 mch_memmove(from + ip->bw_restlen, buf, (size_t)len);
5193 else
5195 from = buf;
5196 fromlen = len;
5199 if (enc2macroman(from, fromlen,
5200 ip->bw_conv_buf, &len, ip->bw_conv_buflen,
5201 ip->bw_rest, &ip->bw_restlen) == FAIL)
5203 ip->bw_conv_error = TRUE;
5204 return FAIL;
5206 buf = ip->bw_conv_buf;
5208 # endif
5210 # ifdef USE_ICONV
5211 if (ip->bw_iconv_fd != (iconv_t)-1)
5213 const char *from;
5214 size_t fromlen;
5215 char *to;
5216 size_t tolen;
5218 /* Convert with iconv(). */
5219 if (ip->bw_restlen > 0)
5221 /* Need to concatenate the remainder of the previous call and
5222 * the bytes of the current call. Use the end of the
5223 * conversion buffer for this. */
5224 fromlen = len + ip->bw_restlen;
5225 from = (char *)ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
5226 mch_memmove((void *)from, ip->bw_rest, (size_t)ip->bw_restlen);
5227 mch_memmove((void *)(from + ip->bw_restlen), buf, (size_t)len);
5228 tolen = ip->bw_conv_buflen - fromlen;
5230 else
5232 from = (const char *)buf;
5233 fromlen = len;
5234 tolen = ip->bw_conv_buflen;
5236 to = (char *)ip->bw_conv_buf;
5238 if (ip->bw_first)
5240 size_t save_len = tolen;
5242 /* output the initial shift state sequence */
5243 (void)iconv(ip->bw_iconv_fd, NULL, NULL, &to, &tolen);
5245 /* There is a bug in iconv() on Linux (which appears to be
5246 * wide-spread) which sets "to" to NULL and messes up "tolen".
5248 if (to == NULL)
5250 to = (char *)ip->bw_conv_buf;
5251 tolen = save_len;
5253 ip->bw_first = FALSE;
5257 * If iconv() has an error or there is not enough room, fail.
5259 if ((iconv(ip->bw_iconv_fd, (void *)&from, &fromlen, &to, &tolen)
5260 == (size_t)-1 && ICONV_ERRNO != ICONV_EINVAL)
5261 || fromlen > CONV_RESTLEN)
5263 ip->bw_conv_error = TRUE;
5264 return FAIL;
5267 /* copy remainder to ip->bw_rest[] to be used for the next call. */
5268 if (fromlen > 0)
5269 mch_memmove(ip->bw_rest, (void *)from, fromlen);
5270 ip->bw_restlen = (int)fromlen;
5272 buf = ip->bw_conv_buf;
5273 len = (int)((char_u *)to - ip->bw_conv_buf);
5275 # endif
5277 #endif /* FEAT_MBYTE */
5279 #ifdef FEAT_CRYPT
5280 if (flags & FIO_ENCRYPTED) /* encrypt the data */
5282 int ztemp, t, i;
5284 for (i = 0; i < len; i++)
5286 ztemp = buf[i];
5287 buf[i] = ZENCODE(ztemp, t);
5290 #endif
5292 /* Repeat the write(), it may be interrupted by a signal. */
5293 while (len > 0)
5295 wlen = vim_write(ip->bw_fd, buf, len);
5296 if (wlen <= 0) /* error! */
5297 return FAIL;
5298 len -= wlen;
5299 buf += wlen;
5301 return OK;
5304 #ifdef FEAT_MBYTE
5306 * Convert a Unicode character to bytes.
5308 static int
5309 ucs2bytes(c, pp, flags)
5310 unsigned c; /* in: character */
5311 char_u **pp; /* in/out: pointer to result */
5312 int flags; /* FIO_ flags */
5314 char_u *p = *pp;
5315 int error = FALSE;
5316 int cc;
5319 if (flags & FIO_UCS4)
5321 if (flags & FIO_ENDIAN_L)
5323 *p++ = c;
5324 *p++ = (c >> 8);
5325 *p++ = (c >> 16);
5326 *p++ = (c >> 24);
5328 else
5330 *p++ = (c >> 24);
5331 *p++ = (c >> 16);
5332 *p++ = (c >> 8);
5333 *p++ = c;
5336 else if (flags & (FIO_UCS2 | FIO_UTF16))
5338 if (c >= 0x10000)
5340 if (flags & FIO_UTF16)
5342 /* Make two words, ten bits of the character in each. First
5343 * word is 0xd800 - 0xdbff, second one 0xdc00 - 0xdfff */
5344 c -= 0x10000;
5345 if (c >= 0x100000)
5346 error = TRUE;
5347 cc = ((c >> 10) & 0x3ff) + 0xd800;
5348 if (flags & FIO_ENDIAN_L)
5350 *p++ = cc;
5351 *p++ = ((unsigned)cc >> 8);
5353 else
5355 *p++ = ((unsigned)cc >> 8);
5356 *p++ = cc;
5358 c = (c & 0x3ff) + 0xdc00;
5360 else
5361 error = TRUE;
5363 if (flags & FIO_ENDIAN_L)
5365 *p++ = c;
5366 *p++ = (c >> 8);
5368 else
5370 *p++ = (c >> 8);
5371 *p++ = c;
5374 else /* Latin1 */
5376 if (c >= 0x100)
5378 error = TRUE;
5379 *p++ = 0xBF;
5381 else
5382 *p++ = c;
5385 *pp = p;
5386 return error;
5390 * Return TRUE if "a" and "b" are the same 'encoding'.
5391 * Ignores difference between "ansi" and "latin1", "ucs-4" and "ucs-4be", etc.
5393 static int
5394 same_encoding(a, b)
5395 char_u *a;
5396 char_u *b;
5398 int f;
5400 if (STRCMP(a, b) == 0)
5401 return TRUE;
5402 f = get_fio_flags(a);
5403 return (f != 0 && get_fio_flags(b) == f);
5407 * Check "ptr" for a unicode encoding and return the FIO_ flags needed for the
5408 * internal conversion.
5409 * if "ptr" is an empty string, use 'encoding'.
5411 static int
5412 get_fio_flags(ptr)
5413 char_u *ptr;
5415 int prop;
5417 if (*ptr == NUL)
5418 ptr = p_enc;
5420 prop = enc_canon_props(ptr);
5421 if (prop & ENC_UNICODE)
5423 if (prop & ENC_2BYTE)
5425 if (prop & ENC_ENDIAN_L)
5426 return FIO_UCS2 | FIO_ENDIAN_L;
5427 return FIO_UCS2;
5429 if (prop & ENC_4BYTE)
5431 if (prop & ENC_ENDIAN_L)
5432 return FIO_UCS4 | FIO_ENDIAN_L;
5433 return FIO_UCS4;
5435 if (prop & ENC_2WORD)
5437 if (prop & ENC_ENDIAN_L)
5438 return FIO_UTF16 | FIO_ENDIAN_L;
5439 return FIO_UTF16;
5441 return FIO_UTF8;
5443 if (prop & ENC_LATIN1)
5444 return FIO_LATIN1;
5445 /* must be ENC_DBCS, requires iconv() */
5446 return 0;
5449 #ifdef WIN3264
5451 * Check "ptr" for a MS-Windows codepage name and return the FIO_ flags needed
5452 * for the conversion MS-Windows can do for us. Also accept "utf-8".
5453 * Used for conversion between 'encoding' and 'fileencoding'.
5455 static int
5456 get_win_fio_flags(ptr)
5457 char_u *ptr;
5459 int cp;
5461 /* Cannot do this when 'encoding' is not utf-8 and not a codepage. */
5462 if (!enc_utf8 && enc_codepage <= 0)
5463 return 0;
5465 cp = encname2codepage(ptr);
5466 if (cp == 0)
5468 # ifdef CP_UTF8 /* VC 4.1 doesn't define CP_UTF8 */
5469 if (STRCMP(ptr, "utf-8") == 0)
5470 cp = CP_UTF8;
5471 else
5472 # endif
5473 return 0;
5475 return FIO_PUT_CP(cp) | FIO_CODEPAGE;
5477 #endif
5479 #ifdef MACOS_X
5481 * Check "ptr" for a Carbon supported encoding and return the FIO_ flags
5482 * needed for the internal conversion to/from utf-8 or latin1.
5484 static int
5485 get_mac_fio_flags(ptr)
5486 char_u *ptr;
5488 if ((enc_utf8 || STRCMP(p_enc, "latin1") == 0)
5489 && (enc_canon_props(ptr) & ENC_MACROMAN))
5490 return FIO_MACROMAN;
5491 return 0;
5493 #endif
5496 * Check for a Unicode BOM (Byte Order Mark) at the start of p[size].
5497 * "size" must be at least 2.
5498 * Return the name of the encoding and set "*lenp" to the length.
5499 * Returns NULL when no BOM found.
5501 static char_u *
5502 check_for_bom(p, size, lenp, flags)
5503 char_u *p;
5504 long size;
5505 int *lenp;
5506 int flags;
5508 char *name = NULL;
5509 int len = 2;
5511 if (p[0] == 0xef && p[1] == 0xbb && size >= 3 && p[2] == 0xbf
5512 && (flags == FIO_ALL || flags == 0))
5514 name = "utf-8"; /* EF BB BF */
5515 len = 3;
5517 else if (p[0] == 0xff && p[1] == 0xfe)
5519 if (size >= 4 && p[2] == 0 && p[3] == 0
5520 && (flags == FIO_ALL || flags == (FIO_UCS4 | FIO_ENDIAN_L)))
5522 name = "ucs-4le"; /* FF FE 00 00 */
5523 len = 4;
5525 else if (flags == FIO_ALL || flags == (FIO_UCS2 | FIO_ENDIAN_L))
5526 name = "ucs-2le"; /* FF FE */
5527 else if (flags == (FIO_UTF16 | FIO_ENDIAN_L))
5528 name = "utf-16le"; /* FF FE */
5530 else if (p[0] == 0xfe && p[1] == 0xff
5531 && (flags == FIO_ALL || flags == FIO_UCS2 || flags == FIO_UTF16))
5533 /* Default to utf-16, it works also for ucs-2 text. */
5534 if (flags == FIO_UCS2)
5535 name = "ucs-2"; /* FE FF */
5536 else
5537 name = "utf-16"; /* FE FF */
5539 else if (size >= 4 && p[0] == 0 && p[1] == 0 && p[2] == 0xfe
5540 && p[3] == 0xff && (flags == FIO_ALL || flags == FIO_UCS4))
5542 name = "ucs-4"; /* 00 00 FE FF */
5543 len = 4;
5546 *lenp = len;
5547 return (char_u *)name;
5551 * Generate a BOM in "buf[4]" for encoding "name".
5552 * Return the length of the BOM (zero when no BOM).
5554 static int
5555 make_bom(buf, name)
5556 char_u *buf;
5557 char_u *name;
5559 int flags;
5560 char_u *p;
5562 flags = get_fio_flags(name);
5564 /* Can't put a BOM in a non-Unicode file. */
5565 if (flags == FIO_LATIN1 || flags == 0)
5566 return 0;
5568 if (flags == FIO_UTF8) /* UTF-8 */
5570 buf[0] = 0xef;
5571 buf[1] = 0xbb;
5572 buf[2] = 0xbf;
5573 return 3;
5575 p = buf;
5576 (void)ucs2bytes(0xfeff, &p, flags);
5577 return (int)(p - buf);
5579 #endif
5581 #if defined(FEAT_VIMINFO) || defined(FEAT_BROWSE) || \
5582 defined(FEAT_QUICKFIX) || defined(FEAT_AUTOCMD) || defined(PROTO)
5584 * Try to find a shortname by comparing the fullname with the current
5585 * directory.
5586 * Returns "full_path" or pointer into "full_path" if shortened.
5588 char_u *
5589 shorten_fname1(full_path)
5590 char_u *full_path;
5592 char_u dirname[MAXPATHL];
5593 char_u *p = full_path;
5595 if (mch_dirname(dirname, MAXPATHL) == OK)
5597 p = shorten_fname(full_path, dirname);
5598 if (p == NULL || *p == NUL)
5599 p = full_path;
5601 return p;
5603 #endif
5606 * Try to find a shortname by comparing the fullname with the current
5607 * directory.
5608 * Returns NULL if not shorter name possible, pointer into "full_path"
5609 * otherwise.
5611 char_u *
5612 shorten_fname(full_path, dir_name)
5613 char_u *full_path;
5614 char_u *dir_name;
5616 int len;
5617 char_u *p;
5619 if (full_path == NULL)
5620 return NULL;
5621 len = (int)STRLEN(dir_name);
5622 if (fnamencmp(dir_name, full_path, len) == 0)
5624 p = full_path + len;
5625 #if defined(MSDOS) || defined(MSWIN) || defined(OS2)
5627 * MSDOS: when a file is in the root directory, dir_name will end in a
5628 * slash, since C: by itself does not define a specific dir. In this
5629 * case p may already be correct. <negri>
5631 if (!((len > 2) && (*(p - 2) == ':')))
5632 #endif
5634 if (vim_ispathsep(*p))
5635 ++p;
5636 #ifndef VMS /* the path separator is always part of the path */
5637 else
5638 p = NULL;
5639 #endif
5642 #if defined(MSDOS) || defined(MSWIN) || defined(OS2)
5644 * When using a file in the current drive, remove the drive name:
5645 * "A:\dir\file" -> "\dir\file". This helps when moving a session file on
5646 * a floppy from "A:\dir" to "B:\dir".
5648 else if (len > 3
5649 && TOUPPER_LOC(full_path[0]) == TOUPPER_LOC(dir_name[0])
5650 && full_path[1] == ':'
5651 && vim_ispathsep(full_path[2]))
5652 p = full_path + 2;
5653 #endif
5654 else
5655 p = NULL;
5656 return p;
5660 * Shorten filenames for all buffers.
5661 * When "force" is TRUE: Use full path from now on for files currently being
5662 * edited, both for file name and swap file name. Try to shorten the file
5663 * names a bit, if safe to do so.
5664 * When "force" is FALSE: Only try to shorten absolute file names.
5665 * For buffers that have buftype "nofile" or "scratch": never change the file
5666 * name.
5668 void
5669 shorten_fnames(force)
5670 int force;
5672 char_u dirname[MAXPATHL];
5673 buf_T *buf;
5674 char_u *p;
5676 mch_dirname(dirname, MAXPATHL);
5677 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
5679 if (buf->b_fname != NULL
5680 #ifdef FEAT_QUICKFIX
5681 && !bt_nofile(buf)
5682 #endif
5683 && !path_with_url(buf->b_fname)
5684 && (force
5685 || buf->b_sfname == NULL
5686 || mch_isFullName(buf->b_sfname)))
5688 vim_free(buf->b_sfname);
5689 buf->b_sfname = NULL;
5690 p = shorten_fname(buf->b_ffname, dirname);
5691 if (p != NULL)
5693 buf->b_sfname = vim_strsave(p);
5694 buf->b_fname = buf->b_sfname;
5696 if (p == NULL || buf->b_fname == NULL)
5697 buf->b_fname = buf->b_ffname;
5700 /* Always make the swap file name a full path, a "nofile" buffer may
5701 * also have a swap file. */
5702 mf_fullname(buf->b_ml.ml_mfp);
5704 #ifdef FEAT_WINDOWS
5705 status_redraw_all();
5706 redraw_tabline = TRUE;
5707 #endif
5710 #if (defined(FEAT_DND) && defined(FEAT_GUI_GTK)) \
5711 || defined(FEAT_GUI_MSWIN) \
5712 || defined(FEAT_GUI_MAC) \
5713 || defined(PROTO) \
5714 || defined(FEAT_GUI_MACVIM)
5716 * Shorten all filenames in "fnames[count]" by current directory.
5718 void
5719 shorten_filenames(fnames, count)
5720 char_u **fnames;
5721 int count;
5723 int i;
5724 char_u dirname[MAXPATHL];
5725 char_u *p;
5727 if (fnames == NULL || count < 1)
5728 return;
5729 mch_dirname(dirname, sizeof(dirname));
5730 for (i = 0; i < count; ++i)
5732 if ((p = shorten_fname(fnames[i], dirname)) != NULL)
5734 /* shorten_fname() returns pointer in given "fnames[i]". If free
5735 * "fnames[i]" first, "p" becomes invalid. So we need to copy
5736 * "p" first then free fnames[i]. */
5737 p = vim_strsave(p);
5738 vim_free(fnames[i]);
5739 fnames[i] = p;
5743 #endif
5746 * add extention to file name - change path/fo.o.h to path/fo.o.h.ext or
5747 * fo_o_h.ext for MSDOS or when shortname option set.
5749 * Assumed that fname is a valid name found in the filesystem we assure that
5750 * the return value is a different name and ends in 'ext'.
5751 * "ext" MUST be at most 4 characters long if it starts with a dot, 3
5752 * characters otherwise.
5753 * Space for the returned name is allocated, must be freed later.
5754 * Returns NULL when out of memory.
5756 char_u *
5757 modname(fname, ext, prepend_dot)
5758 char_u *fname, *ext;
5759 int prepend_dot; /* may prepend a '.' to file name */
5761 return buf_modname(
5762 #ifdef SHORT_FNAME
5763 TRUE,
5764 #else
5765 (curbuf->b_p_sn || curbuf->b_shortname),
5766 #endif
5767 fname, ext, prepend_dot);
5770 char_u *
5771 buf_modname(shortname, fname, ext, prepend_dot)
5772 int shortname; /* use 8.3 file name */
5773 char_u *fname, *ext;
5774 int prepend_dot; /* may prepend a '.' to file name */
5776 char_u *retval;
5777 char_u *s;
5778 char_u *e;
5779 char_u *ptr;
5780 int fnamelen, extlen;
5782 extlen = (int)STRLEN(ext);
5785 * If there is no file name we must get the name of the current directory
5786 * (we need the full path in case :cd is used).
5788 if (fname == NULL || *fname == NUL)
5790 retval = alloc((unsigned)(MAXPATHL + extlen + 3));
5791 if (retval == NULL)
5792 return NULL;
5793 if (mch_dirname(retval, MAXPATHL) == FAIL ||
5794 (fnamelen = (int)STRLEN(retval)) == 0)
5796 vim_free(retval);
5797 return NULL;
5799 if (!after_pathsep(retval, retval + fnamelen))
5801 retval[fnamelen++] = PATHSEP;
5802 retval[fnamelen] = NUL;
5804 #ifndef SHORT_FNAME
5805 prepend_dot = FALSE; /* nothing to prepend a dot to */
5806 #endif
5808 else
5810 fnamelen = (int)STRLEN(fname);
5811 retval = alloc((unsigned)(fnamelen + extlen + 3));
5812 if (retval == NULL)
5813 return NULL;
5814 STRCPY(retval, fname);
5815 #ifdef VMS
5816 vms_remove_version(retval); /* we do not need versions here */
5817 #endif
5821 * search backwards until we hit a '/', '\' or ':' replacing all '.'
5822 * by '_' for MSDOS or when shortname option set and ext starts with a dot.
5823 * Then truncate what is after the '/', '\' or ':' to 8 characters for
5824 * MSDOS and 26 characters for AMIGA, a lot more for UNIX.
5826 for (ptr = retval + fnamelen; ptr > retval; mb_ptr_back(retval, ptr))
5828 #ifndef RISCOS
5829 if (*ext == '.'
5830 # ifdef USE_LONG_FNAME
5831 && (!USE_LONG_FNAME || shortname)
5832 # else
5833 # ifndef SHORT_FNAME
5834 && shortname
5835 # endif
5836 # endif
5838 if (*ptr == '.') /* replace '.' by '_' */
5839 *ptr = '_';
5840 #endif
5841 if (vim_ispathsep(*ptr))
5843 ++ptr;
5844 break;
5848 /* the file name has at most BASENAMELEN characters. */
5849 #ifndef SHORT_FNAME
5850 if (STRLEN(ptr) > (unsigned)BASENAMELEN)
5851 ptr[BASENAMELEN] = '\0';
5852 #endif
5854 s = ptr + STRLEN(ptr);
5857 * For 8.3 file names we may have to reduce the length.
5859 #ifdef USE_LONG_FNAME
5860 if (!USE_LONG_FNAME || shortname)
5861 #else
5862 # ifndef SHORT_FNAME
5863 if (shortname)
5864 # endif
5865 #endif
5868 * If there is no file name, or the file name ends in '/', and the
5869 * extension starts with '.', put a '_' before the dot, because just
5870 * ".ext" is invalid.
5872 if (fname == NULL || *fname == NUL
5873 || vim_ispathsep(fname[STRLEN(fname) - 1]))
5875 #ifdef RISCOS
5876 if (*ext == '/')
5877 #else
5878 if (*ext == '.')
5879 #endif
5880 *s++ = '_';
5883 * If the extension starts with '.', truncate the base name at 8
5884 * characters
5886 #ifdef RISCOS
5887 /* We normally use '/', but swap files are '_' */
5888 else if (*ext == '/' || *ext == '_')
5889 #else
5890 else if (*ext == '.')
5891 #endif
5893 if (s - ptr > (size_t)8)
5895 s = ptr + 8;
5896 *s = '\0';
5900 * If the extension doesn't start with '.', and the file name
5901 * doesn't have an extension yet, append a '.'
5903 #ifdef RISCOS
5904 else if ((e = vim_strchr(ptr, '/')) == NULL)
5905 *s++ = '/';
5906 #else
5907 else if ((e = vim_strchr(ptr, '.')) == NULL)
5908 *s++ = '.';
5909 #endif
5911 * If the extension doesn't start with '.', and there already is an
5912 * extension, it may need to be truncated
5914 else if ((int)STRLEN(e) + extlen > 4)
5915 s = e + 4 - extlen;
5917 #if defined(OS2) || defined(USE_LONG_FNAME) || defined(WIN3264)
5919 * If there is no file name, and the extension starts with '.', put a
5920 * '_' before the dot, because just ".ext" may be invalid if it's on a
5921 * FAT partition, and on HPFS it doesn't matter.
5923 else if ((fname == NULL || *fname == NUL) && *ext == '.')
5924 *s++ = '_';
5925 #endif
5928 * Append the extention.
5929 * ext can start with '.' and cannot exceed 3 more characters.
5931 STRCPY(s, ext);
5933 #ifndef SHORT_FNAME
5935 * Prepend the dot.
5937 if (prepend_dot && !shortname && *(e = gettail(retval)) !=
5938 #ifdef RISCOS
5940 #else
5942 #endif
5943 #ifdef USE_LONG_FNAME
5944 && USE_LONG_FNAME
5945 #endif
5948 mch_memmove(e + 1, e, STRLEN(e) + 1);
5949 #ifdef RISCOS
5950 *e = '/';
5951 #else
5952 *e = '.';
5953 #endif
5955 #endif
5958 * Check that, after appending the extension, the file name is really
5959 * different.
5961 if (fname != NULL && STRCMP(fname, retval) == 0)
5963 /* we search for a character that can be replaced by '_' */
5964 while (--s >= ptr)
5966 if (*s != '_')
5968 *s = '_';
5969 break;
5972 if (s < ptr) /* fname was "________.<ext>", how tricky! */
5973 *ptr = 'v';
5975 return retval;
5979 * Like fgets(), but if the file line is too long, it is truncated and the
5980 * rest of the line is thrown away. Returns TRUE for end-of-file.
5983 vim_fgets(buf, size, fp)
5984 char_u *buf;
5985 int size;
5986 FILE *fp;
5988 char *eof;
5989 #define FGETS_SIZE 200
5990 char tbuf[FGETS_SIZE];
5992 buf[size - 2] = NUL;
5993 #ifdef USE_CR
5994 eof = fgets_cr((char *)buf, size, fp);
5995 #else
5996 eof = fgets((char *)buf, size, fp);
5997 #endif
5998 if (buf[size - 2] != NUL && buf[size - 2] != '\n')
6000 buf[size - 1] = NUL; /* Truncate the line */
6002 /* Now throw away the rest of the line: */
6005 tbuf[FGETS_SIZE - 2] = NUL;
6006 #ifdef USE_CR
6007 fgets_cr((char *)tbuf, FGETS_SIZE, fp);
6008 #else
6009 fgets((char *)tbuf, FGETS_SIZE, fp);
6010 #endif
6011 } while (tbuf[FGETS_SIZE - 2] != NUL && tbuf[FGETS_SIZE - 2] != '\n');
6013 return (eof == NULL);
6016 #if defined(USE_CR) || defined(PROTO)
6018 * Like vim_fgets(), but accept any line terminator: CR, CR-LF or LF.
6019 * Returns TRUE for end-of-file.
6020 * Only used for the Mac, because it's much slower than vim_fgets().
6023 tag_fgets(buf, size, fp)
6024 char_u *buf;
6025 int size;
6026 FILE *fp;
6028 int i = 0;
6029 int c;
6030 int eof = FALSE;
6032 for (;;)
6034 c = fgetc(fp);
6035 if (c == EOF)
6037 eof = TRUE;
6038 break;
6040 if (c == '\r')
6042 /* Always store a NL for end-of-line. */
6043 if (i < size - 1)
6044 buf[i++] = '\n';
6045 c = fgetc(fp);
6046 if (c != '\n') /* Macintosh format: single CR. */
6047 ungetc(c, fp);
6048 break;
6050 if (i < size - 1)
6051 buf[i++] = c;
6052 if (c == '\n')
6053 break;
6055 buf[i] = NUL;
6056 return eof;
6058 #endif
6061 * rename() only works if both files are on the same file system, this
6062 * function will (attempts to?) copy the file across if rename fails -- webb
6063 * Return -1 for failure, 0 for success.
6066 vim_rename(from, to)
6067 char_u *from;
6068 char_u *to;
6070 int fd_in;
6071 int fd_out;
6072 int n;
6073 char *errmsg = NULL;
6074 char *buffer;
6075 #ifdef AMIGA
6076 BPTR flock;
6077 #endif
6078 struct stat st;
6079 long perm;
6080 #ifdef HAVE_ACL
6081 vim_acl_T acl; /* ACL from original file */
6082 #endif
6085 * When the names are identical, there is nothing to do.
6087 if (fnamecmp(from, to) == 0)
6088 return 0;
6091 * Fail if the "from" file doesn't exist. Avoids that "to" is deleted.
6093 if (mch_stat((char *)from, &st) < 0)
6094 return -1;
6097 * Delete the "to" file, this is required on some systems to make the
6098 * mch_rename() work, on other systems it makes sure that we don't have
6099 * two files when the mch_rename() fails.
6102 #ifdef AMIGA
6104 * With MSDOS-compatible filesystems (crossdos, messydos) it is possible
6105 * that the name of the "to" file is the same as the "from" file, even
6106 * though the names are different. To avoid the chance of accidentally
6107 * deleting the "from" file (horror!) we lock it during the remove.
6109 * When used for making a backup before writing the file: This should not
6110 * happen with ":w", because startscript() should detect this problem and
6111 * set buf->b_shortname, causing modname() to return a correct ".bak" file
6112 * name. This problem does exist with ":w filename", but then the
6113 * original file will be somewhere else so the backup isn't really
6114 * important. If autoscripting is off the rename may fail.
6116 flock = Lock((UBYTE *)from, (long)ACCESS_READ);
6117 #endif
6118 mch_remove(to);
6119 #ifdef AMIGA
6120 if (flock)
6121 UnLock(flock);
6122 #endif
6125 * First try a normal rename, return if it works.
6127 if (mch_rename((char *)from, (char *)to) == 0)
6128 return 0;
6131 * Rename() failed, try copying the file.
6133 perm = mch_getperm(from);
6134 #ifdef HAVE_ACL
6135 /* For systems that support ACL: get the ACL from the original file. */
6136 acl = mch_get_acl(from);
6137 #endif
6138 fd_in = mch_open((char *)from, O_RDONLY|O_EXTRA, 0);
6139 if (fd_in == -1)
6140 return -1;
6142 /* Create the new file with same permissions as the original. */
6143 fd_out = mch_open((char *)to,
6144 O_CREAT|O_EXCL|O_WRONLY|O_EXTRA|O_NOFOLLOW, (int)perm);
6145 if (fd_out == -1)
6147 close(fd_in);
6148 return -1;
6151 buffer = (char *)alloc(BUFSIZE);
6152 if (buffer == NULL)
6154 close(fd_in);
6155 close(fd_out);
6156 return -1;
6159 while ((n = vim_read(fd_in, buffer, BUFSIZE)) > 0)
6160 if (vim_write(fd_out, buffer, n) != n)
6162 errmsg = _("E208: Error writing to \"%s\"");
6163 break;
6166 vim_free(buffer);
6167 close(fd_in);
6168 if (close(fd_out) < 0)
6169 errmsg = _("E209: Error closing \"%s\"");
6170 if (n < 0)
6172 errmsg = _("E210: Error reading \"%s\"");
6173 to = from;
6175 #ifndef UNIX /* for Unix mch_open() already set the permission */
6176 mch_setperm(to, perm);
6177 #endif
6178 #ifdef HAVE_ACL
6179 mch_set_acl(to, acl);
6180 #endif
6181 if (errmsg != NULL)
6183 EMSG2(errmsg, to);
6184 return -1;
6186 mch_remove(from);
6187 return 0;
6190 static int already_warned = FALSE;
6193 * Check if any not hidden buffer has been changed.
6194 * Postpone the check if there are characters in the stuff buffer, a global
6195 * command is being executed, a mapping is being executed or an autocommand is
6196 * busy.
6197 * Returns TRUE if some message was written (screen should be redrawn and
6198 * cursor positioned).
6201 check_timestamps(focus)
6202 int focus; /* called for GUI focus event */
6204 buf_T *buf;
6205 int didit = 0;
6206 int n;
6208 /* Don't check timestamps while system() or another low-level function may
6209 * cause us to lose and gain focus. */
6210 if (no_check_timestamps > 0)
6211 return FALSE;
6213 /* Avoid doing a check twice. The OK/Reload dialog can cause a focus
6214 * event and we would keep on checking if the file is steadily growing.
6215 * Do check again after typing something. */
6216 if (focus && did_check_timestamps)
6218 need_check_timestamps = TRUE;
6219 return FALSE;
6222 if (!stuff_empty() || global_busy || !typebuf_typed()
6223 #ifdef FEAT_AUTOCMD
6224 || autocmd_busy || curbuf_lock > 0
6225 #endif
6227 need_check_timestamps = TRUE; /* check later */
6228 else
6230 ++no_wait_return;
6231 did_check_timestamps = TRUE;
6232 already_warned = FALSE;
6233 for (buf = firstbuf; buf != NULL; )
6235 /* Only check buffers in a window. */
6236 if (buf->b_nwindows > 0)
6238 n = buf_check_timestamp(buf, focus);
6239 if (didit < n)
6240 didit = n;
6241 if (n > 0 && !buf_valid(buf))
6243 /* Autocommands have removed the buffer, start at the
6244 * first one again. */
6245 buf = firstbuf;
6246 continue;
6249 buf = buf->b_next;
6251 --no_wait_return;
6252 need_check_timestamps = FALSE;
6253 if (need_wait_return && didit == 2)
6255 /* make sure msg isn't overwritten */
6256 msg_puts((char_u *)"\n");
6257 out_flush();
6260 return didit;
6264 * Move all the lines from buffer "frombuf" to buffer "tobuf".
6265 * Return OK or FAIL. When FAIL "tobuf" is incomplete and/or "frombuf" is not
6266 * empty.
6268 static int
6269 move_lines(frombuf, tobuf)
6270 buf_T *frombuf;
6271 buf_T *tobuf;
6273 buf_T *tbuf = curbuf;
6274 int retval = OK;
6275 linenr_T lnum;
6276 char_u *p;
6278 /* Copy the lines in "frombuf" to "tobuf". */
6279 curbuf = tobuf;
6280 for (lnum = 1; lnum <= frombuf->b_ml.ml_line_count; ++lnum)
6282 p = vim_strsave(ml_get_buf(frombuf, lnum, FALSE));
6283 if (p == NULL || ml_append(lnum - 1, p, 0, FALSE) == FAIL)
6285 vim_free(p);
6286 retval = FAIL;
6287 break;
6289 vim_free(p);
6292 /* Delete all the lines in "frombuf". */
6293 if (retval != FAIL)
6295 curbuf = frombuf;
6296 for (lnum = curbuf->b_ml.ml_line_count; lnum > 0; --lnum)
6297 if (ml_delete(lnum, FALSE) == FAIL)
6299 /* Oops! We could try putting back the saved lines, but that
6300 * might fail again... */
6301 retval = FAIL;
6302 break;
6306 curbuf = tbuf;
6307 return retval;
6311 * Check if buffer "buf" has been changed.
6312 * Also check if the file for a new buffer unexpectedly appeared.
6313 * return 1 if a changed buffer was found.
6314 * return 2 if a message has been displayed.
6315 * return 0 otherwise.
6317 /*ARGSUSED*/
6319 buf_check_timestamp(buf, focus)
6320 buf_T *buf;
6321 int focus; /* called for GUI focus event */
6323 struct stat st;
6324 int stat_res;
6325 int retval = 0;
6326 char_u *path;
6327 char_u *tbuf;
6328 char *mesg = NULL;
6329 char *mesg2 = "";
6330 int helpmesg = FALSE;
6331 int reload = FALSE;
6332 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6333 int can_reload = FALSE;
6334 #endif
6335 size_t orig_size = buf->b_orig_size;
6336 int orig_mode = buf->b_orig_mode;
6337 #ifdef FEAT_GUI
6338 int save_mouse_correct = need_mouse_correct;
6339 #endif
6340 #ifdef FEAT_AUTOCMD
6341 static int busy = FALSE;
6342 int n;
6343 char_u *s;
6344 #endif
6345 char *reason;
6347 /* If there is no file name, the buffer is not loaded, 'buftype' is
6348 * set, we are in the middle of a save or being called recursively: ignore
6349 * this buffer. */
6350 if (buf->b_ffname == NULL
6351 || buf->b_ml.ml_mfp == NULL
6352 #if defined(FEAT_QUICKFIX)
6353 || *buf->b_p_bt != NUL
6354 #endif
6355 || buf->b_saving
6356 #ifdef FEAT_AUTOCMD
6357 || busy
6358 #endif
6359 #ifdef FEAT_NETBEANS_INTG
6360 || isNetbeansBuffer(buf)
6361 #endif
6363 return 0;
6365 if ( !(buf->b_flags & BF_NOTEDITED)
6366 && buf->b_mtime != 0
6367 && ((stat_res = mch_stat((char *)buf->b_ffname, &st)) < 0
6368 || time_differs((long)st.st_mtime, buf->b_mtime)
6369 #ifdef HAVE_ST_MODE
6370 || (int)st.st_mode != buf->b_orig_mode
6371 #else
6372 || mch_getperm(buf->b_ffname) != buf->b_orig_mode
6373 #endif
6376 retval = 1;
6378 /* set b_mtime to stop further warnings (e.g., when executing
6379 * FileChangedShell autocmd) */
6380 if (stat_res < 0)
6382 buf->b_mtime = 0;
6383 buf->b_orig_size = 0;
6384 buf->b_orig_mode = 0;
6386 else
6387 buf_store_time(buf, &st, buf->b_ffname);
6389 /* Don't do anything for a directory. Might contain the file
6390 * explorer. */
6391 if (mch_isdir(buf->b_fname))
6395 * If 'autoread' is set, the buffer has no changes and the file still
6396 * exists, reload the buffer. Use the buffer-local option value if it
6397 * was set, the global option value otherwise.
6399 else if ((buf->b_p_ar >= 0 ? buf->b_p_ar : p_ar)
6400 && !bufIsChanged(buf) && stat_res >= 0)
6401 reload = TRUE;
6402 else
6404 if (stat_res < 0)
6405 reason = "deleted";
6406 else if (bufIsChanged(buf))
6407 reason = "conflict";
6408 else if (orig_size != buf->b_orig_size || buf_contents_changed(buf))
6409 reason = "changed";
6410 else if (orig_mode != buf->b_orig_mode)
6411 reason = "mode";
6412 else
6413 reason = "time";
6415 #ifdef FEAT_AUTOCMD
6417 * Only give the warning if there are no FileChangedShell
6418 * autocommands.
6419 * Avoid being called recursively by setting "busy".
6421 busy = TRUE;
6422 # ifdef FEAT_EVAL
6423 set_vim_var_string(VV_FCS_REASON, (char_u *)reason, -1);
6424 set_vim_var_string(VV_FCS_CHOICE, (char_u *)"", -1);
6425 # endif
6426 n = apply_autocmds(EVENT_FILECHANGEDSHELL,
6427 buf->b_fname, buf->b_fname, FALSE, buf);
6428 busy = FALSE;
6429 if (n)
6431 if (!buf_valid(buf))
6432 EMSG(_("E246: FileChangedShell autocommand deleted buffer"));
6433 # ifdef FEAT_EVAL
6434 s = get_vim_var_str(VV_FCS_CHOICE);
6435 if (STRCMP(s, "reload") == 0 && *reason != 'd')
6436 reload = TRUE;
6437 else if (STRCMP(s, "ask") == 0)
6438 n = FALSE;
6439 else
6440 # endif
6441 return 2;
6443 if (!n)
6444 #endif
6446 if (*reason == 'd')
6447 mesg = _("E211: File \"%s\" no longer available");
6448 else
6450 helpmesg = TRUE;
6451 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6452 can_reload = TRUE;
6453 #endif
6455 * Check if the file contents really changed to avoid
6456 * giving a warning when only the timestamp was set (e.g.,
6457 * checked out of CVS). Always warn when the buffer was
6458 * changed.
6460 if (reason[2] == 'n')
6462 mesg = _("W12: Warning: File \"%s\" has changed and the buffer was changed in Vim as well");
6463 mesg2 = _("See \":help W12\" for more info.");
6465 else if (reason[1] == 'h')
6467 mesg = _("W11: Warning: File \"%s\" has changed since editing started");
6468 mesg2 = _("See \":help W11\" for more info.");
6470 else if (*reason == 'm')
6472 mesg = _("W16: Warning: Mode of file \"%s\" has changed since editing started");
6473 mesg2 = _("See \":help W16\" for more info.");
6475 /* Else: only timestamp changed, ignored */
6481 else if ((buf->b_flags & BF_NEW) && !(buf->b_flags & BF_NEW_W)
6482 && vim_fexists(buf->b_ffname))
6484 retval = 1;
6485 mesg = _("W13: Warning: File \"%s\" has been created after editing started");
6486 buf->b_flags |= BF_NEW_W;
6487 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6488 can_reload = TRUE;
6489 #endif
6492 if (mesg != NULL)
6494 path = home_replace_save(buf, buf->b_fname);
6495 if (path != NULL)
6497 if (!helpmesg)
6498 mesg2 = "";
6499 tbuf = alloc((unsigned)(STRLEN(path) + STRLEN(mesg)
6500 + STRLEN(mesg2) + 2));
6501 sprintf((char *)tbuf, mesg, path);
6502 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6503 if (can_reload)
6505 if (*mesg2 != NUL)
6507 STRCAT(tbuf, "\n");
6508 STRCAT(tbuf, mesg2);
6510 if (do_dialog(VIM_WARNING, (char_u *)_("Warning"), tbuf,
6511 (char_u *)_("&OK\n&Load File"), 1, NULL) == 2)
6512 reload = TRUE;
6514 else
6515 #endif
6516 if (State > NORMAL_BUSY || (State & CMDLINE) || already_warned)
6518 if (*mesg2 != NUL)
6520 STRCAT(tbuf, "; ");
6521 STRCAT(tbuf, mesg2);
6523 EMSG(tbuf);
6524 retval = 2;
6526 else
6528 # ifdef FEAT_AUTOCMD
6529 if (!autocmd_busy)
6530 # endif
6532 msg_start();
6533 msg_puts_attr(tbuf, hl_attr(HLF_E) + MSG_HIST);
6534 if (*mesg2 != NUL)
6535 msg_puts_attr((char_u *)mesg2,
6536 hl_attr(HLF_W) + MSG_HIST);
6537 msg_clr_eos();
6538 (void)msg_end();
6539 if (emsg_silent == 0)
6541 out_flush();
6542 # ifdef FEAT_GUI
6543 if (!focus)
6544 # endif
6545 /* give the user some time to think about it */
6546 ui_delay(1000L, TRUE);
6548 /* don't redraw and erase the message */
6549 redraw_cmdline = FALSE;
6552 already_warned = TRUE;
6555 vim_free(path);
6556 vim_free(tbuf);
6560 if (reload)
6561 /* Reload the buffer. */
6562 buf_reload(buf, orig_mode);
6564 #ifdef FEAT_AUTOCMD
6565 if (buf_valid(buf))
6566 (void)apply_autocmds(EVENT_FILECHANGEDSHELLPOST,
6567 buf->b_fname, buf->b_fname, FALSE, buf);
6568 #endif
6569 #ifdef FEAT_GUI
6570 /* restore this in case an autocommand has set it; it would break
6571 * 'mousefocus' */
6572 need_mouse_correct = save_mouse_correct;
6573 #endif
6575 return retval;
6579 * Reload a buffer that is already loaded.
6580 * Used when the file was changed outside of Vim.
6581 * "orig_mode" is buf->b_orig_mode before the need for reloading was detected.
6582 * buf->b_orig_mode may have been reset already.
6584 void
6585 buf_reload(buf, orig_mode)
6586 buf_T *buf;
6587 int orig_mode;
6589 exarg_T ea;
6590 pos_T old_cursor;
6591 linenr_T old_topline;
6592 int old_ro = buf->b_p_ro;
6593 buf_T *savebuf;
6594 int saved = OK;
6595 aco_save_T aco;
6597 /* set curwin/curbuf for "buf" and save some things */
6598 aucmd_prepbuf(&aco, buf);
6600 /* We only want to read the text from the file, not reset the syntax
6601 * highlighting, clear marks, diff status, etc. Force the fileformat
6602 * and encoding to be the same. */
6603 if (prep_exarg(&ea, buf) == OK)
6605 old_cursor = curwin->w_cursor;
6606 old_topline = curwin->w_topline;
6609 * To behave like when a new file is edited (matters for
6610 * BufReadPost autocommands) we first need to delete the current
6611 * buffer contents. But if reading the file fails we should keep
6612 * the old contents. Can't use memory only, the file might be
6613 * too big. Use a hidden buffer to move the buffer contents to.
6615 if (bufempty())
6616 savebuf = NULL;
6617 else
6619 /* Allocate a buffer without putting it in the buffer list. */
6620 savebuf = buflist_new(NULL, NULL, (linenr_T)1, BLN_DUMMY);
6621 if (savebuf != NULL && buf == curbuf)
6623 /* Open the memline. */
6624 curbuf = savebuf;
6625 curwin->w_buffer = savebuf;
6626 saved = ml_open(curbuf);
6627 curbuf = buf;
6628 curwin->w_buffer = buf;
6630 if (savebuf == NULL || saved == FAIL || buf != curbuf
6631 || move_lines(buf, savebuf) == FAIL)
6633 EMSG2(_("E462: Could not prepare for reloading \"%s\""),
6634 buf->b_fname);
6635 saved = FAIL;
6639 if (saved == OK)
6641 curbuf->b_flags |= BF_CHECK_RO; /* check for RO again */
6642 #ifdef FEAT_AUTOCMD
6643 keep_filetype = TRUE; /* don't detect 'filetype' */
6644 #endif
6645 if (readfile(buf->b_ffname, buf->b_fname, (linenr_T)0,
6646 (linenr_T)0,
6647 (linenr_T)MAXLNUM, &ea, READ_NEW) == FAIL)
6649 #if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
6650 if (!aborting())
6651 #endif
6652 EMSG2(_("E321: Could not reload \"%s\""), buf->b_fname);
6653 if (savebuf != NULL && buf_valid(savebuf) && buf == curbuf)
6655 /* Put the text back from the save buffer. First
6656 * delete any lines that readfile() added. */
6657 while (!bufempty())
6658 if (ml_delete(buf->b_ml.ml_line_count, FALSE) == FAIL)
6659 break;
6660 (void)move_lines(savebuf, buf);
6663 else if (buf == curbuf)
6665 /* Mark the buffer as unmodified and free undo info. */
6666 unchanged(buf, TRUE);
6667 u_blockfree(buf);
6668 u_clearall(buf);
6671 vim_free(ea.cmd);
6673 if (savebuf != NULL && buf_valid(savebuf))
6674 wipe_buffer(savebuf, FALSE);
6676 #ifdef FEAT_DIFF
6677 /* Invalidate diff info if necessary. */
6678 diff_invalidate(curbuf);
6679 #endif
6681 /* Restore the topline and cursor position and check it (lines may
6682 * have been removed). */
6683 if (old_topline > curbuf->b_ml.ml_line_count)
6684 curwin->w_topline = curbuf->b_ml.ml_line_count;
6685 else
6686 curwin->w_topline = old_topline;
6687 curwin->w_cursor = old_cursor;
6688 check_cursor();
6689 update_topline();
6690 #ifdef FEAT_AUTOCMD
6691 keep_filetype = FALSE;
6692 #endif
6693 #ifdef FEAT_FOLDING
6695 win_T *wp;
6697 /* Update folds unless they are defined manually. */
6698 FOR_ALL_WINDOWS(wp)
6699 if (wp->w_buffer == curwin->w_buffer
6700 && !foldmethodIsManual(wp))
6701 foldUpdateAll(wp);
6703 #endif
6704 /* If the mode didn't change and 'readonly' was set, keep the old
6705 * value; the user probably used the ":view" command. But don't
6706 * reset it, might have had a read error. */
6707 if (orig_mode == curbuf->b_orig_mode)
6708 curbuf->b_p_ro |= old_ro;
6711 /* restore curwin/curbuf and a few other things */
6712 aucmd_restbuf(&aco);
6713 /* Careful: autocommands may have made "buf" invalid! */
6716 /*ARGSUSED*/
6717 void
6718 buf_store_time(buf, st, fname)
6719 buf_T *buf;
6720 struct stat *st;
6721 char_u *fname;
6723 buf->b_mtime = (long)st->st_mtime;
6724 buf->b_orig_size = (size_t)st->st_size;
6725 #ifdef HAVE_ST_MODE
6726 buf->b_orig_mode = (int)st->st_mode;
6727 #else
6728 buf->b_orig_mode = mch_getperm(fname);
6729 #endif
6733 * Adjust the line with missing eol, used for the next write.
6734 * Used for do_filter(), when the input lines for the filter are deleted.
6736 void
6737 write_lnum_adjust(offset)
6738 linenr_T offset;
6740 if (write_no_eol_lnum != 0) /* only if there is a missing eol */
6741 write_no_eol_lnum += offset;
6744 #if defined(TEMPDIRNAMES) || defined(PROTO)
6745 static long temp_count = 0; /* Temp filename counter. */
6748 * Delete the temp directory and all files it contains.
6750 void
6751 vim_deltempdir()
6753 char_u **files;
6754 int file_count;
6755 int i;
6757 if (vim_tempdir != NULL)
6759 sprintf((char *)NameBuff, "%s*", vim_tempdir);
6760 if (gen_expand_wildcards(1, &NameBuff, &file_count, &files,
6761 EW_DIR|EW_FILE|EW_SILENT) == OK)
6763 for (i = 0; i < file_count; ++i)
6764 mch_remove(files[i]);
6765 FreeWild(file_count, files);
6767 gettail(NameBuff)[-1] = NUL;
6768 (void)mch_rmdir(NameBuff);
6770 vim_free(vim_tempdir);
6771 vim_tempdir = NULL;
6774 #endif
6777 * vim_tempname(): Return a unique name that can be used for a temp file.
6779 * The temp file is NOT created.
6781 * The returned pointer is to allocated memory.
6782 * The returned pointer is NULL if no valid name was found.
6784 /*ARGSUSED*/
6785 char_u *
6786 vim_tempname(extra_char)
6787 int extra_char; /* character to use in the name instead of '?' */
6789 #ifdef USE_TMPNAM
6790 char_u itmp[L_tmpnam]; /* use tmpnam() */
6791 #else
6792 char_u itmp[TEMPNAMELEN];
6793 #endif
6795 #ifdef TEMPDIRNAMES
6796 static char *(tempdirs[]) = {TEMPDIRNAMES};
6797 int i;
6798 long nr;
6799 long off;
6800 # ifndef EEXIST
6801 struct stat st;
6802 # endif
6805 * This will create a directory for private use by this instance of Vim.
6806 * This is done once, and the same directory is used for all temp files.
6807 * This method avoids security problems because of symlink attacks et al.
6808 * It's also a bit faster, because we only need to check for an existing
6809 * file when creating the directory and not for each temp file.
6811 if (vim_tempdir == NULL)
6814 * Try the entries in TEMPDIRNAMES to create the temp directory.
6816 for (i = 0; i < sizeof(tempdirs) / sizeof(char *); ++i)
6818 /* expand $TMP, leave room for "/v1100000/999999999" */
6819 expand_env((char_u *)tempdirs[i], itmp, TEMPNAMELEN - 20);
6820 if (mch_isdir(itmp)) /* directory exists */
6822 # ifdef __EMX__
6823 /* If $TMP contains a forward slash (perhaps using bash or
6824 * tcsh), don't add a backslash, use a forward slash!
6825 * Adding 2 backslashes didn't work. */
6826 if (vim_strchr(itmp, '/') != NULL)
6827 STRCAT(itmp, "/");
6828 else
6829 # endif
6830 add_pathsep(itmp);
6832 /* Get an arbitrary number of up to 6 digits. When it's
6833 * unlikely that it already exists it will be faster,
6834 * otherwise it doesn't matter. The use of mkdir() avoids any
6835 * security problems because of the predictable number. */
6836 nr = (mch_get_pid() + (long)time(NULL)) % 1000000L;
6838 /* Try up to 10000 different values until we find a name that
6839 * doesn't exist. */
6840 for (off = 0; off < 10000L; ++off)
6842 int r;
6843 #if defined(UNIX) || defined(VMS)
6844 mode_t umask_save;
6845 #endif
6847 sprintf((char *)itmp + STRLEN(itmp), "v%ld", nr + off);
6848 # ifndef EEXIST
6849 /* If mkdir() does not set errno to EEXIST, check for
6850 * existing file here. There is a race condition then,
6851 * although it's fail-safe. */
6852 if (mch_stat((char *)itmp, &st) >= 0)
6853 continue;
6854 # endif
6855 #if defined(UNIX) || defined(VMS)
6856 /* Make sure the umask doesn't remove the executable bit.
6857 * "repl" has been reported to use "177". */
6858 umask_save = umask(077);
6859 #endif
6860 r = vim_mkdir(itmp, 0700);
6861 #if defined(UNIX) || defined(VMS)
6862 (void)umask(umask_save);
6863 #endif
6864 if (r == 0)
6866 char_u *buf;
6868 /* Directory was created, use this name.
6869 * Expand to full path; When using the current
6870 * directory a ":cd" would confuse us. */
6871 buf = alloc((unsigned)MAXPATHL + 1);
6872 if (buf != NULL)
6874 if (vim_FullName(itmp, buf, MAXPATHL, FALSE)
6875 == FAIL)
6876 STRCPY(buf, itmp);
6877 # ifdef __EMX__
6878 if (vim_strchr(buf, '/') != NULL)
6879 STRCAT(buf, "/");
6880 else
6881 # endif
6882 add_pathsep(buf);
6883 vim_tempdir = vim_strsave(buf);
6884 vim_free(buf);
6886 break;
6888 # ifdef EEXIST
6889 /* If the mkdir() didn't fail because the file/dir exists,
6890 * we probably can't create any dir here, try another
6891 * place. */
6892 if (errno != EEXIST)
6893 # endif
6894 break;
6896 if (vim_tempdir != NULL)
6897 break;
6902 if (vim_tempdir != NULL)
6904 /* There is no need to check if the file exists, because we own the
6905 * directory and nobody else creates a file in it. */
6906 sprintf((char *)itmp, "%s%ld", vim_tempdir, temp_count++);
6907 return vim_strsave(itmp);
6910 return NULL;
6912 #else /* TEMPDIRNAMES */
6914 # ifdef WIN3264
6915 char szTempFile[_MAX_PATH + 1];
6916 char buf4[4];
6917 char_u *retval;
6918 char_u *p;
6920 STRCPY(itmp, "");
6921 if (GetTempPath(_MAX_PATH, szTempFile) == 0)
6922 szTempFile[0] = NUL; /* GetTempPath() failed, use current dir */
6923 strcpy(buf4, "VIM");
6924 buf4[2] = extra_char; /* make it "VIa", "VIb", etc. */
6925 if (GetTempFileName(szTempFile, buf4, 0, itmp) == 0)
6926 return NULL;
6927 /* GetTempFileName() will create the file, we don't want that */
6928 (void)DeleteFile(itmp);
6930 /* Backslashes in a temp file name cause problems when filtering with
6931 * "sh". NOTE: This also checks 'shellcmdflag' to help those people who
6932 * didn't set 'shellslash'. */
6933 retval = vim_strsave(itmp);
6934 if (*p_shcf == '-' || p_ssl)
6935 for (p = retval; *p; ++p)
6936 if (*p == '\\')
6937 *p = '/';
6938 return retval;
6940 # else /* WIN3264 */
6942 # ifdef USE_TMPNAM
6943 /* tmpnam() will make its own name */
6944 if (*tmpnam((char *)itmp) == NUL)
6945 return NULL;
6946 # else
6947 char_u *p;
6949 # ifdef VMS_TEMPNAM
6950 /* mktemp() is not working on VMS. It seems to be
6951 * a do-nothing function. Therefore we use tempnam().
6953 sprintf((char *)itmp, "VIM%c", extra_char);
6954 p = (char_u *)tempnam("tmp:", (char *)itmp);
6955 if (p != NULL)
6957 /* VMS will use '.LOG' if we don't explicitly specify an extension,
6958 * and VIM will then be unable to find the file later */
6959 STRCPY(itmp, p);
6960 STRCAT(itmp, ".txt");
6961 free(p);
6963 else
6964 return NULL;
6965 # else
6966 STRCPY(itmp, TEMPNAME);
6967 if ((p = vim_strchr(itmp, '?')) != NULL)
6968 *p = extra_char;
6969 if (mktemp((char *)itmp) == NULL)
6970 return NULL;
6971 # endif
6972 # endif
6974 return vim_strsave(itmp);
6975 # endif /* WIN3264 */
6976 #endif /* TEMPDIRNAMES */
6979 #if defined(BACKSLASH_IN_FILENAME) || defined(PROTO)
6981 * Convert all backslashes in fname to forward slashes in-place.
6983 void
6984 forward_slash(fname)
6985 char_u *fname;
6987 char_u *p;
6989 for (p = fname; *p != NUL; ++p)
6990 # ifdef FEAT_MBYTE
6991 /* The Big5 encoding can have '\' in the trail byte. */
6992 if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
6993 ++p;
6994 else
6995 # endif
6996 if (*p == '\\')
6997 *p = '/';
6999 #endif
7003 * Code for automatic commands.
7005 * Only included when "FEAT_AUTOCMD" has been defined.
7008 #if defined(FEAT_AUTOCMD) || defined(PROTO)
7011 * The autocommands are stored in a list for each event.
7012 * Autocommands for the same pattern, that are consecutive, are joined
7013 * together, to avoid having to match the pattern too often.
7014 * The result is an array of Autopat lists, which point to AutoCmd lists:
7016 * first_autopat[0] --> Autopat.next --> Autopat.next --> NULL
7017 * Autopat.cmds Autopat.cmds
7018 * | |
7019 * V V
7020 * AutoCmd.next AutoCmd.next
7021 * | |
7022 * V V
7023 * AutoCmd.next NULL
7026 * NULL
7028 * first_autopat[1] --> Autopat.next --> NULL
7029 * Autopat.cmds
7032 * AutoCmd.next
7035 * NULL
7036 * etc.
7038 * The order of AutoCmds is important, this is the order in which they were
7039 * defined and will have to be executed.
7041 typedef struct AutoCmd
7043 char_u *cmd; /* The command to be executed (NULL
7044 when command has been removed) */
7045 char nested; /* If autocommands nest here */
7046 char last; /* last command in list */
7047 #ifdef FEAT_EVAL
7048 scid_T scriptID; /* script ID where defined */
7049 #endif
7050 struct AutoCmd *next; /* Next AutoCmd in list */
7051 } AutoCmd;
7053 typedef struct AutoPat
7055 int group; /* group ID */
7056 char_u *pat; /* pattern as typed (NULL when pattern
7057 has been removed) */
7058 int patlen; /* strlen() of pat */
7059 regprog_T *reg_prog; /* compiled regprog for pattern */
7060 char allow_dirs; /* Pattern may match whole path */
7061 char last; /* last pattern for apply_autocmds() */
7062 AutoCmd *cmds; /* list of commands to do */
7063 struct AutoPat *next; /* next AutoPat in AutoPat list */
7064 int buflocal_nr; /* !=0 for buffer-local AutoPat */
7065 } AutoPat;
7067 static struct event_name
7069 char *name; /* event name */
7070 event_T event; /* event number */
7071 } event_names[] =
7073 {"BufAdd", EVENT_BUFADD},
7074 {"BufCreate", EVENT_BUFADD},
7075 {"BufDelete", EVENT_BUFDELETE},
7076 {"BufEnter", EVENT_BUFENTER},
7077 {"BufFilePost", EVENT_BUFFILEPOST},
7078 {"BufFilePre", EVENT_BUFFILEPRE},
7079 {"BufHidden", EVENT_BUFHIDDEN},
7080 {"BufLeave", EVENT_BUFLEAVE},
7081 {"BufNew", EVENT_BUFNEW},
7082 {"BufNewFile", EVENT_BUFNEWFILE},
7083 {"BufRead", EVENT_BUFREADPOST},
7084 {"BufReadCmd", EVENT_BUFREADCMD},
7085 {"BufReadPost", EVENT_BUFREADPOST},
7086 {"BufReadPre", EVENT_BUFREADPRE},
7087 {"BufUnload", EVENT_BUFUNLOAD},
7088 {"BufWinEnter", EVENT_BUFWINENTER},
7089 {"BufWinLeave", EVENT_BUFWINLEAVE},
7090 {"BufWipeout", EVENT_BUFWIPEOUT},
7091 {"BufWrite", EVENT_BUFWRITEPRE},
7092 {"BufWritePost", EVENT_BUFWRITEPOST},
7093 {"BufWritePre", EVENT_BUFWRITEPRE},
7094 {"BufWriteCmd", EVENT_BUFWRITECMD},
7095 {"CmdwinEnter", EVENT_CMDWINENTER},
7096 {"CmdwinLeave", EVENT_CMDWINLEAVE},
7097 {"ColorScheme", EVENT_COLORSCHEME},
7098 {"CursorHold", EVENT_CURSORHOLD},
7099 {"CursorHoldI", EVENT_CURSORHOLDI},
7100 {"CursorMoved", EVENT_CURSORMOVED},
7101 {"CursorMovedI", EVENT_CURSORMOVEDI},
7102 {"EncodingChanged", EVENT_ENCODINGCHANGED},
7103 {"FileEncoding", EVENT_ENCODINGCHANGED},
7104 {"FileAppendPost", EVENT_FILEAPPENDPOST},
7105 {"FileAppendPre", EVENT_FILEAPPENDPRE},
7106 {"FileAppendCmd", EVENT_FILEAPPENDCMD},
7107 {"FileChangedShell",EVENT_FILECHANGEDSHELL},
7108 {"FileChangedShellPost",EVENT_FILECHANGEDSHELLPOST},
7109 {"FileChangedRO", EVENT_FILECHANGEDRO},
7110 {"FileReadPost", EVENT_FILEREADPOST},
7111 {"FileReadPre", EVENT_FILEREADPRE},
7112 {"FileReadCmd", EVENT_FILEREADCMD},
7113 {"FileType", EVENT_FILETYPE},
7114 {"FileWritePost", EVENT_FILEWRITEPOST},
7115 {"FileWritePre", EVENT_FILEWRITEPRE},
7116 {"FileWriteCmd", EVENT_FILEWRITECMD},
7117 {"FilterReadPost", EVENT_FILTERREADPOST},
7118 {"FilterReadPre", EVENT_FILTERREADPRE},
7119 {"FilterWritePost", EVENT_FILTERWRITEPOST},
7120 {"FilterWritePre", EVENT_FILTERWRITEPRE},
7121 {"FocusGained", EVENT_FOCUSGAINED},
7122 {"FocusLost", EVENT_FOCUSLOST},
7123 {"FuncUndefined", EVENT_FUNCUNDEFINED},
7124 {"GUIEnter", EVENT_GUIENTER},
7125 {"GUIFailed", EVENT_GUIFAILED},
7126 {"InsertChange", EVENT_INSERTCHANGE},
7127 {"InsertEnter", EVENT_INSERTENTER},
7128 {"InsertLeave", EVENT_INSERTLEAVE},
7129 {"MenuPopup", EVENT_MENUPOPUP},
7130 {"QuickFixCmdPost", EVENT_QUICKFIXCMDPOST},
7131 {"QuickFixCmdPre", EVENT_QUICKFIXCMDPRE},
7132 {"RemoteReply", EVENT_REMOTEREPLY},
7133 {"SessionLoadPost", EVENT_SESSIONLOADPOST},
7134 {"ShellCmdPost", EVENT_SHELLCMDPOST},
7135 {"ShellFilterPost", EVENT_SHELLFILTERPOST},
7136 {"SourcePre", EVENT_SOURCEPRE},
7137 {"SourceCmd", EVENT_SOURCECMD},
7138 {"SpellFileMissing",EVENT_SPELLFILEMISSING},
7139 {"StdinReadPost", EVENT_STDINREADPOST},
7140 {"StdinReadPre", EVENT_STDINREADPRE},
7141 {"SwapExists", EVENT_SWAPEXISTS},
7142 {"Syntax", EVENT_SYNTAX},
7143 {"TabEnter", EVENT_TABENTER},
7144 {"TabLeave", EVENT_TABLEAVE},
7145 {"TermChanged", EVENT_TERMCHANGED},
7146 {"TermResponse", EVENT_TERMRESPONSE},
7147 {"User", EVENT_USER},
7148 {"VimEnter", EVENT_VIMENTER},
7149 {"VimLeave", EVENT_VIMLEAVE},
7150 {"VimLeavePre", EVENT_VIMLEAVEPRE},
7151 {"WinEnter", EVENT_WINENTER},
7152 {"WinLeave", EVENT_WINLEAVE},
7153 {"VimResized", EVENT_VIMRESIZED},
7154 {NULL, (event_T)0}
7157 static AutoPat *first_autopat[NUM_EVENTS] =
7159 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7160 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7161 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7162 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7163 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7164 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
7168 * struct used to keep status while executing autocommands for an event.
7170 typedef struct AutoPatCmd
7172 AutoPat *curpat; /* next AutoPat to examine */
7173 AutoCmd *nextcmd; /* next AutoCmd to execute */
7174 int group; /* group being used */
7175 char_u *fname; /* fname to match with */
7176 char_u *sfname; /* sfname to match with */
7177 char_u *tail; /* tail of fname */
7178 event_T event; /* current event */
7179 int arg_bufnr; /* initially equal to <abuf>, set to zero when
7180 buf is deleted */
7181 struct AutoPatCmd *next; /* chain of active apc-s for auto-invalidation*/
7182 } AutoPatCmd;
7184 static AutoPatCmd *active_apc_list = NULL; /* stack of active autocommands */
7187 * augroups stores a list of autocmd group names.
7189 static garray_T augroups = {0, 0, sizeof(char_u *), 10, NULL};
7190 #define AUGROUP_NAME(i) (((char_u **)augroups.ga_data)[i])
7193 * The ID of the current group. Group 0 is the default one.
7195 static int current_augroup = AUGROUP_DEFAULT;
7197 static int au_need_clean = FALSE; /* need to delete marked patterns */
7199 static void show_autocmd __ARGS((AutoPat *ap, event_T event));
7200 static void au_remove_pat __ARGS((AutoPat *ap));
7201 static void au_remove_cmds __ARGS((AutoPat *ap));
7202 static void au_cleanup __ARGS((void));
7203 static int au_new_group __ARGS((char_u *name));
7204 static void au_del_group __ARGS((char_u *name));
7205 static event_T event_name2nr __ARGS((char_u *start, char_u **end));
7206 static char_u *event_nr2name __ARGS((event_T event));
7207 static char_u *find_end_event __ARGS((char_u *arg, int have_group));
7208 static int event_ignored __ARGS((event_T event));
7209 static int au_get_grouparg __ARGS((char_u **argp));
7210 static int do_autocmd_event __ARGS((event_T event, char_u *pat, int nested, char_u *cmd, int forceit, int group));
7211 static char_u *getnextac __ARGS((int c, void *cookie, int indent));
7212 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));
7213 static void auto_next_pat __ARGS((AutoPatCmd *apc, int stop_at_last));
7216 static event_T last_event;
7217 static int last_group;
7218 static int autocmd_blocked = 0; /* block all autocmds */
7221 * Show the autocommands for one AutoPat.
7223 static void
7224 show_autocmd(ap, event)
7225 AutoPat *ap;
7226 event_T event;
7228 AutoCmd *ac;
7230 /* Check for "got_int" (here and at various places below), which is set
7231 * when "q" has been hit for the "--more--" prompt */
7232 if (got_int)
7233 return;
7234 if (ap->pat == NULL) /* pattern has been removed */
7235 return;
7237 msg_putchar('\n');
7238 if (got_int)
7239 return;
7240 if (event != last_event || ap->group != last_group)
7242 if (ap->group != AUGROUP_DEFAULT)
7244 if (AUGROUP_NAME(ap->group) == NULL)
7245 msg_puts_attr((char_u *)_("--Deleted--"), hl_attr(HLF_E));
7246 else
7247 msg_puts_attr(AUGROUP_NAME(ap->group), hl_attr(HLF_T));
7248 msg_puts((char_u *)" ");
7250 msg_puts_attr(event_nr2name(event), hl_attr(HLF_T));
7251 last_event = event;
7252 last_group = ap->group;
7253 msg_putchar('\n');
7254 if (got_int)
7255 return;
7257 msg_col = 4;
7258 msg_outtrans(ap->pat);
7260 for (ac = ap->cmds; ac != NULL; ac = ac->next)
7262 if (ac->cmd != NULL) /* skip removed commands */
7264 if (msg_col >= 14)
7265 msg_putchar('\n');
7266 msg_col = 14;
7267 if (got_int)
7268 return;
7269 msg_outtrans(ac->cmd);
7270 #ifdef FEAT_EVAL
7271 if (p_verbose > 0)
7272 last_set_msg(ac->scriptID);
7273 #endif
7274 if (got_int)
7275 return;
7276 if (ac->next != NULL)
7278 msg_putchar('\n');
7279 if (got_int)
7280 return;
7287 * Mark an autocommand pattern for deletion.
7289 static void
7290 au_remove_pat(ap)
7291 AutoPat *ap;
7293 vim_free(ap->pat);
7294 ap->pat = NULL;
7295 ap->buflocal_nr = -1;
7296 au_need_clean = TRUE;
7300 * Mark all commands for a pattern for deletion.
7302 static void
7303 au_remove_cmds(ap)
7304 AutoPat *ap;
7306 AutoCmd *ac;
7308 for (ac = ap->cmds; ac != NULL; ac = ac->next)
7310 vim_free(ac->cmd);
7311 ac->cmd = NULL;
7313 au_need_clean = TRUE;
7317 * Cleanup autocommands and patterns that have been deleted.
7318 * This is only done when not executing autocommands.
7320 static void
7321 au_cleanup()
7323 AutoPat *ap, **prev_ap;
7324 AutoCmd *ac, **prev_ac;
7325 event_T event;
7327 if (autocmd_busy || !au_need_clean)
7328 return;
7330 /* loop over all events */
7331 for (event = (event_T)0; (int)event < (int)NUM_EVENTS;
7332 event = (event_T)((int)event + 1))
7334 /* loop over all autocommand patterns */
7335 prev_ap = &(first_autopat[(int)event]);
7336 for (ap = *prev_ap; ap != NULL; ap = *prev_ap)
7338 /* loop over all commands for this pattern */
7339 prev_ac = &(ap->cmds);
7340 for (ac = *prev_ac; ac != NULL; ac = *prev_ac)
7342 /* remove the command if the pattern is to be deleted or when
7343 * the command has been marked for deletion */
7344 if (ap->pat == NULL || ac->cmd == NULL)
7346 *prev_ac = ac->next;
7347 vim_free(ac->cmd);
7348 vim_free(ac);
7350 else
7351 prev_ac = &(ac->next);
7354 /* remove the pattern if it has been marked for deletion */
7355 if (ap->pat == NULL)
7357 *prev_ap = ap->next;
7358 vim_free(ap->reg_prog);
7359 vim_free(ap);
7361 else
7362 prev_ap = &(ap->next);
7366 au_need_clean = FALSE;
7370 * Called when buffer is freed, to remove/invalidate related buffer-local
7371 * autocmds.
7373 void
7374 aubuflocal_remove(buf)
7375 buf_T *buf;
7377 AutoPat *ap;
7378 event_T event;
7379 AutoPatCmd *apc;
7381 /* invalidate currently executing autocommands */
7382 for (apc = active_apc_list; apc; apc = apc->next)
7383 if (buf->b_fnum == apc->arg_bufnr)
7384 apc->arg_bufnr = 0;
7386 /* invalidate buflocals looping through events */
7387 for (event = (event_T)0; (int)event < (int)NUM_EVENTS;
7388 event = (event_T)((int)event + 1))
7389 /* loop over all autocommand patterns */
7390 for (ap = first_autopat[(int)event]; ap != NULL; ap = ap->next)
7391 if (ap->buflocal_nr == buf->b_fnum)
7393 au_remove_pat(ap);
7394 if (p_verbose >= 6)
7396 verbose_enter();
7397 smsg((char_u *)
7398 _("auto-removing autocommand: %s <buffer=%d>"),
7399 event_nr2name(event), buf->b_fnum);
7400 verbose_leave();
7403 au_cleanup();
7407 * Add an autocmd group name.
7408 * Return it's ID. Returns AUGROUP_ERROR (< 0) for error.
7410 static int
7411 au_new_group(name)
7412 char_u *name;
7414 int i;
7416 i = au_find_group(name);
7417 if (i == AUGROUP_ERROR) /* the group doesn't exist yet, add it */
7419 /* First try using a free entry. */
7420 for (i = 0; i < augroups.ga_len; ++i)
7421 if (AUGROUP_NAME(i) == NULL)
7422 break;
7423 if (i == augroups.ga_len && ga_grow(&augroups, 1) == FAIL)
7424 return AUGROUP_ERROR;
7426 AUGROUP_NAME(i) = vim_strsave(name);
7427 if (AUGROUP_NAME(i) == NULL)
7428 return AUGROUP_ERROR;
7429 if (i == augroups.ga_len)
7430 ++augroups.ga_len;
7433 return i;
7436 static void
7437 au_del_group(name)
7438 char_u *name;
7440 int i;
7442 i = au_find_group(name);
7443 if (i == AUGROUP_ERROR) /* the group doesn't exist */
7444 EMSG2(_("E367: No such group: \"%s\""), name);
7445 else
7447 vim_free(AUGROUP_NAME(i));
7448 AUGROUP_NAME(i) = NULL;
7453 * Find the ID of an autocmd group name.
7454 * Return it's ID. Returns AUGROUP_ERROR (< 0) for error.
7456 static int
7457 au_find_group(name)
7458 char_u *name;
7460 int i;
7462 for (i = 0; i < augroups.ga_len; ++i)
7463 if (AUGROUP_NAME(i) != NULL && STRCMP(AUGROUP_NAME(i), name) == 0)
7464 return i;
7465 return AUGROUP_ERROR;
7469 * Return TRUE if augroup "name" exists.
7472 au_has_group(name)
7473 char_u *name;
7475 return au_find_group(name) != AUGROUP_ERROR;
7479 * ":augroup {name}".
7481 void
7482 do_augroup(arg, del_group)
7483 char_u *arg;
7484 int del_group;
7486 int i;
7488 if (del_group)
7490 if (*arg == NUL)
7491 EMSG(_(e_argreq));
7492 else
7493 au_del_group(arg);
7495 else if (STRICMP(arg, "end") == 0) /* ":aug end": back to group 0 */
7496 current_augroup = AUGROUP_DEFAULT;
7497 else if (*arg) /* ":aug xxx": switch to group xxx */
7499 i = au_new_group(arg);
7500 if (i != AUGROUP_ERROR)
7501 current_augroup = i;
7503 else /* ":aug": list the group names */
7505 msg_start();
7506 for (i = 0; i < augroups.ga_len; ++i)
7508 if (AUGROUP_NAME(i) != NULL)
7510 msg_puts(AUGROUP_NAME(i));
7511 msg_puts((char_u *)" ");
7514 msg_clr_eos();
7515 msg_end();
7519 #if defined(EXITFREE) || defined(PROTO)
7520 void
7521 free_all_autocmds()
7523 for (current_augroup = -1; current_augroup < augroups.ga_len;
7524 ++current_augroup)
7525 do_autocmd((char_u *)"", TRUE);
7526 ga_clear_strings(&augroups);
7528 #endif
7531 * Return the event number for event name "start".
7532 * Return NUM_EVENTS if the event name was not found.
7533 * Return a pointer to the next event name in "end".
7535 static event_T
7536 event_name2nr(start, end)
7537 char_u *start;
7538 char_u **end;
7540 char_u *p;
7541 int i;
7542 int len;
7544 /* the event name ends with end of line, a blank or a comma */
7545 for (p = start; *p && !vim_iswhite(*p) && *p != ','; ++p)
7547 for (i = 0; event_names[i].name != NULL; ++i)
7549 len = (int)STRLEN(event_names[i].name);
7550 if (len == p - start && STRNICMP(event_names[i].name, start, len) == 0)
7551 break;
7553 if (*p == ',')
7554 ++p;
7555 *end = p;
7556 if (event_names[i].name == NULL)
7557 return NUM_EVENTS;
7558 return event_names[i].event;
7562 * Return the name for event "event".
7564 static char_u *
7565 event_nr2name(event)
7566 event_T event;
7568 int i;
7570 for (i = 0; event_names[i].name != NULL; ++i)
7571 if (event_names[i].event == event)
7572 return (char_u *)event_names[i].name;
7573 return (char_u *)"Unknown";
7577 * Scan over the events. "*" stands for all events.
7579 static char_u *
7580 find_end_event(arg, have_group)
7581 char_u *arg;
7582 int have_group; /* TRUE when group name was found */
7584 char_u *pat;
7585 char_u *p;
7587 if (*arg == '*')
7589 if (arg[1] && !vim_iswhite(arg[1]))
7591 EMSG2(_("E215: Illegal character after *: %s"), arg);
7592 return NULL;
7594 pat = arg + 1;
7596 else
7598 for (pat = arg; *pat && !vim_iswhite(*pat); pat = p)
7600 if ((int)event_name2nr(pat, &p) >= (int)NUM_EVENTS)
7602 if (have_group)
7603 EMSG2(_("E216: No such event: %s"), pat);
7604 else
7605 EMSG2(_("E216: No such group or event: %s"), pat);
7606 return NULL;
7610 return pat;
7614 * Return TRUE if "event" is included in 'eventignore'.
7616 static int
7617 event_ignored(event)
7618 event_T event;
7620 char_u *p = p_ei;
7622 while (*p != NUL)
7624 if (STRNICMP(p, "all", 3) == 0 && (p[3] == NUL || p[3] == ','))
7625 return TRUE;
7626 if (event_name2nr(p, &p) == event)
7627 return TRUE;
7630 return FALSE;
7634 * Return OK when the contents of p_ei is valid, FAIL otherwise.
7637 check_ei()
7639 char_u *p = p_ei;
7641 while (*p)
7643 if (STRNICMP(p, "all", 3) == 0 && (p[3] == NUL || p[3] == ','))
7645 p += 3;
7646 if (*p == ',')
7647 ++p;
7649 else if (event_name2nr(p, &p) == NUM_EVENTS)
7650 return FAIL;
7653 return OK;
7656 # if defined(FEAT_SYN_HL) || defined(PROTO)
7659 * Add "what" to 'eventignore' to skip loading syntax highlighting for every
7660 * buffer loaded into the window. "what" must start with a comma.
7661 * Returns the old value of 'eventignore' in allocated memory.
7663 char_u *
7664 au_event_disable(what)
7665 char *what;
7667 char_u *new_ei;
7668 char_u *save_ei;
7670 save_ei = vim_strsave(p_ei);
7671 if (save_ei != NULL)
7673 new_ei = vim_strnsave(p_ei, (int)(STRLEN(p_ei) + STRLEN(what)));
7674 if (new_ei != NULL)
7676 STRCAT(new_ei, what);
7677 set_string_option_direct((char_u *)"ei", -1, new_ei,
7678 OPT_FREE, SID_NONE);
7679 vim_free(new_ei);
7682 return save_ei;
7685 void
7686 au_event_restore(old_ei)
7687 char_u *old_ei;
7689 if (old_ei != NULL)
7691 set_string_option_direct((char_u *)"ei", -1, old_ei,
7692 OPT_FREE, SID_NONE);
7693 vim_free(old_ei);
7696 # endif /* FEAT_SYN_HL */
7699 * do_autocmd() -- implements the :autocmd command. Can be used in the
7700 * following ways:
7702 * :autocmd <event> <pat> <cmd> Add <cmd> to the list of commands that
7703 * will be automatically executed for <event>
7704 * when editing a file matching <pat>, in
7705 * the current group.
7706 * :autocmd <event> <pat> Show the auto-commands associated with
7707 * <event> and <pat>.
7708 * :autocmd <event> Show the auto-commands associated with
7709 * <event>.
7710 * :autocmd Show all auto-commands.
7711 * :autocmd! <event> <pat> <cmd> Remove all auto-commands associated with
7712 * <event> and <pat>, and add the command
7713 * <cmd>, for the current group.
7714 * :autocmd! <event> <pat> Remove all auto-commands associated with
7715 * <event> and <pat> for the current group.
7716 * :autocmd! <event> Remove all auto-commands associated with
7717 * <event> for the current group.
7718 * :autocmd! Remove ALL auto-commands for the current
7719 * group.
7721 * Multiple events and patterns may be given separated by commas. Here are
7722 * some examples:
7723 * :autocmd bufread,bufenter *.c,*.h set tw=0 smartindent noic
7724 * :autocmd bufleave * set tw=79 nosmartindent ic infercase
7726 * :autocmd * *.c show all autocommands for *.c files.
7728 * Mostly a {group} argument can optionally appear before <event>.
7730 void
7731 do_autocmd(arg, forceit)
7732 char_u *arg;
7733 int forceit;
7735 char_u *pat;
7736 char_u *envpat = NULL;
7737 char_u *cmd;
7738 event_T event;
7739 int need_free = FALSE;
7740 int nested = FALSE;
7741 int group;
7744 * Check for a legal group name. If not, use AUGROUP_ALL.
7746 group = au_get_grouparg(&arg);
7747 if (arg == NULL) /* out of memory */
7748 return;
7751 * Scan over the events.
7752 * If we find an illegal name, return here, don't do anything.
7754 pat = find_end_event(arg, group != AUGROUP_ALL);
7755 if (pat == NULL)
7756 return;
7759 * Scan over the pattern. Put a NUL at the end.
7761 pat = skipwhite(pat);
7762 cmd = pat;
7763 while (*cmd && (!vim_iswhite(*cmd) || cmd[-1] == '\\'))
7764 cmd++;
7765 if (*cmd)
7766 *cmd++ = NUL;
7768 /* Expand environment variables in the pattern. Set 'shellslash', we want
7769 * forward slashes here. */
7770 if (vim_strchr(pat, '$') != NULL || vim_strchr(pat, '~') != NULL)
7772 #ifdef BACKSLASH_IN_FILENAME
7773 int p_ssl_save = p_ssl;
7775 p_ssl = TRUE;
7776 #endif
7777 envpat = expand_env_save(pat);
7778 #ifdef BACKSLASH_IN_FILENAME
7779 p_ssl = p_ssl_save;
7780 #endif
7781 if (envpat != NULL)
7782 pat = envpat;
7786 * Check for "nested" flag.
7788 cmd = skipwhite(cmd);
7789 if (*cmd != NUL && STRNCMP(cmd, "nested", 6) == 0 && vim_iswhite(cmd[6]))
7791 nested = TRUE;
7792 cmd = skipwhite(cmd + 6);
7796 * Find the start of the commands.
7797 * Expand <sfile> in it.
7799 if (*cmd != NUL)
7801 cmd = expand_sfile(cmd);
7802 if (cmd == NULL) /* some error */
7803 return;
7804 need_free = TRUE;
7808 * Print header when showing autocommands.
7810 if (!forceit && *cmd == NUL)
7812 /* Highlight title */
7813 MSG_PUTS_TITLE(_("\n--- Auto-Commands ---"));
7817 * Loop over the events.
7819 last_event = (event_T)-1; /* for listing the event name */
7820 last_group = AUGROUP_ERROR; /* for listing the group name */
7821 if (*arg == '*' || *arg == NUL)
7823 for (event = (event_T)0; (int)event < (int)NUM_EVENTS;
7824 event = (event_T)((int)event + 1))
7825 if (do_autocmd_event(event, pat,
7826 nested, cmd, forceit, group) == FAIL)
7827 break;
7829 else
7831 while (*arg && !vim_iswhite(*arg))
7832 if (do_autocmd_event(event_name2nr(arg, &arg), pat,
7833 nested, cmd, forceit, group) == FAIL)
7834 break;
7837 if (need_free)
7838 vim_free(cmd);
7839 vim_free(envpat);
7843 * Find the group ID in a ":autocmd" or ":doautocmd" argument.
7844 * The "argp" argument is advanced to the following argument.
7846 * Returns the group ID, AUGROUP_ERROR for error (out of memory).
7848 static int
7849 au_get_grouparg(argp)
7850 char_u **argp;
7852 char_u *group_name;
7853 char_u *p;
7854 char_u *arg = *argp;
7855 int group = AUGROUP_ALL;
7857 p = skiptowhite(arg);
7858 if (p > arg)
7860 group_name = vim_strnsave(arg, (int)(p - arg));
7861 if (group_name == NULL) /* out of memory */
7862 return AUGROUP_ERROR;
7863 group = au_find_group(group_name);
7864 if (group == AUGROUP_ERROR)
7865 group = AUGROUP_ALL; /* no match, use all groups */
7866 else
7867 *argp = skipwhite(p); /* match, skip over group name */
7868 vim_free(group_name);
7870 return group;
7874 * do_autocmd() for one event.
7875 * If *pat == NUL do for all patterns.
7876 * If *cmd == NUL show entries.
7877 * If forceit == TRUE delete entries.
7878 * If group is not AUGROUP_ALL, only use this group.
7880 static int
7881 do_autocmd_event(event, pat, nested, cmd, forceit, group)
7882 event_T event;
7883 char_u *pat;
7884 int nested;
7885 char_u *cmd;
7886 int forceit;
7887 int group;
7889 AutoPat *ap;
7890 AutoPat **prev_ap;
7891 AutoCmd *ac;
7892 AutoCmd **prev_ac;
7893 int brace_level;
7894 char_u *endpat;
7895 int findgroup;
7896 int allgroups;
7897 int patlen;
7898 int is_buflocal;
7899 int buflocal_nr;
7900 char_u buflocal_pat[25]; /* for "<buffer=X>" */
7902 if (group == AUGROUP_ALL)
7903 findgroup = current_augroup;
7904 else
7905 findgroup = group;
7906 allgroups = (group == AUGROUP_ALL && !forceit && *cmd == NUL);
7909 * Show or delete all patterns for an event.
7911 if (*pat == NUL)
7913 for (ap = first_autopat[(int)event]; ap != NULL; ap = ap->next)
7915 if (forceit) /* delete the AutoPat, if it's in the current group */
7917 if (ap->group == findgroup)
7918 au_remove_pat(ap);
7920 else if (group == AUGROUP_ALL || ap->group == group)
7921 show_autocmd(ap, event);
7926 * Loop through all the specified patterns.
7928 for ( ; *pat; pat = (*endpat == ',' ? endpat + 1 : endpat))
7931 * Find end of the pattern.
7932 * Watch out for a comma in braces, like "*.\{obj,o\}".
7934 brace_level = 0;
7935 for (endpat = pat; *endpat && (*endpat != ',' || brace_level
7936 || endpat[-1] == '\\'); ++endpat)
7938 if (*endpat == '{')
7939 brace_level++;
7940 else if (*endpat == '}')
7941 brace_level--;
7943 if (pat == endpat) /* ignore single comma */
7944 continue;
7945 patlen = (int)(endpat - pat);
7948 * detect special <buflocal[=X]> buffer-local patterns
7950 is_buflocal = FALSE;
7951 buflocal_nr = 0;
7953 if (patlen >= 7 && STRNCMP(pat, "<buffer", 7) == 0
7954 && pat[patlen - 1] == '>')
7956 /* Error will be printed only for addition. printing and removing
7957 * will proceed silently. */
7958 is_buflocal = TRUE;
7959 if (patlen == 8)
7960 buflocal_nr = curbuf->b_fnum;
7961 else if (patlen > 9 && pat[7] == '=')
7963 /* <buffer=abuf> */
7964 if (patlen == 13 && STRNICMP(pat, "<buffer=abuf>", 13))
7965 buflocal_nr = autocmd_bufnr;
7966 /* <buffer=123> */
7967 else if (skipdigits(pat + 8) == pat + patlen - 1)
7968 buflocal_nr = atoi((char *)pat + 8);
7972 if (is_buflocal)
7974 /* normalize pat into standard "<buffer>#N" form */
7975 sprintf((char *)buflocal_pat, "<buffer=%d>", buflocal_nr);
7976 pat = buflocal_pat; /* can modify pat and patlen */
7977 patlen = (int)STRLEN(buflocal_pat); /* but not endpat */
7981 * Find AutoPat entries with this pattern.
7983 prev_ap = &first_autopat[(int)event];
7984 while ((ap = *prev_ap) != NULL)
7986 if (ap->pat != NULL)
7988 /* Accept a pattern when:
7989 * - a group was specified and it's that group, or a group was
7990 * not specified and it's the current group, or a group was
7991 * not specified and we are listing
7992 * - the length of the pattern matches
7993 * - the pattern matches.
7994 * For <buffer[=X]>, this condition works because we normalize
7995 * all buffer-local patterns.
7997 if ((allgroups || ap->group == findgroup)
7998 && ap->patlen == patlen
7999 && STRNCMP(pat, ap->pat, patlen) == 0)
8002 * Remove existing autocommands.
8003 * If adding any new autocmd's for this AutoPat, don't
8004 * delete the pattern from the autopat list, append to
8005 * this list.
8007 if (forceit)
8009 if (*cmd != NUL && ap->next == NULL)
8011 au_remove_cmds(ap);
8012 break;
8014 au_remove_pat(ap);
8018 * Show autocmd's for this autopat, or buflocals <buffer=X>
8020 else if (*cmd == NUL)
8021 show_autocmd(ap, event);
8024 * Add autocmd to this autopat, if it's the last one.
8026 else if (ap->next == NULL)
8027 break;
8030 prev_ap = &ap->next;
8034 * Add a new command.
8036 if (*cmd != NUL)
8039 * If the pattern we want to add a command to does appear at the
8040 * end of the list (or not is not in the list at all), add the
8041 * pattern at the end of the list.
8043 if (ap == NULL)
8045 /* refuse to add buffer-local ap if buffer number is invalid */
8046 if (is_buflocal && (buflocal_nr == 0
8047 || buflist_findnr(buflocal_nr) == NULL))
8049 EMSGN(_("E680: <buffer=%d>: invalid buffer number "),
8050 buflocal_nr);
8051 return FAIL;
8054 ap = (AutoPat *)alloc((unsigned)sizeof(AutoPat));
8055 if (ap == NULL)
8056 return FAIL;
8057 ap->pat = vim_strnsave(pat, patlen);
8058 ap->patlen = patlen;
8059 if (ap->pat == NULL)
8061 vim_free(ap);
8062 return FAIL;
8065 if (is_buflocal)
8067 ap->buflocal_nr = buflocal_nr;
8068 ap->reg_prog = NULL;
8070 else
8072 char_u *reg_pat;
8074 ap->buflocal_nr = 0;
8075 reg_pat = file_pat_to_reg_pat(pat, endpat,
8076 &ap->allow_dirs, TRUE);
8077 if (reg_pat != NULL)
8078 ap->reg_prog = vim_regcomp(reg_pat, RE_MAGIC);
8079 vim_free(reg_pat);
8080 if (reg_pat == NULL || ap->reg_prog == NULL)
8082 vim_free(ap->pat);
8083 vim_free(ap);
8084 return FAIL;
8087 ap->cmds = NULL;
8088 *prev_ap = ap;
8089 ap->next = NULL;
8090 if (group == AUGROUP_ALL)
8091 ap->group = current_augroup;
8092 else
8093 ap->group = group;
8097 * Add the autocmd at the end of the AutoCmd list.
8099 prev_ac = &(ap->cmds);
8100 while ((ac = *prev_ac) != NULL)
8101 prev_ac = &ac->next;
8102 ac = (AutoCmd *)alloc((unsigned)sizeof(AutoCmd));
8103 if (ac == NULL)
8104 return FAIL;
8105 ac->cmd = vim_strsave(cmd);
8106 #ifdef FEAT_EVAL
8107 ac->scriptID = current_SID;
8108 #endif
8109 if (ac->cmd == NULL)
8111 vim_free(ac);
8112 return FAIL;
8114 ac->next = NULL;
8115 *prev_ac = ac;
8116 ac->nested = nested;
8120 au_cleanup(); /* may really delete removed patterns/commands now */
8121 return OK;
8125 * Implementation of ":doautocmd [group] event [fname]".
8126 * Return OK for success, FAIL for failure;
8129 do_doautocmd(arg, do_msg)
8130 char_u *arg;
8131 int do_msg; /* give message for no matching autocmds? */
8133 char_u *fname;
8134 int nothing_done = TRUE;
8135 int group;
8138 * Check for a legal group name. If not, use AUGROUP_ALL.
8140 group = au_get_grouparg(&arg);
8141 if (arg == NULL) /* out of memory */
8142 return FAIL;
8144 if (*arg == '*')
8146 EMSG(_("E217: Can't execute autocommands for ALL events"));
8147 return FAIL;
8151 * Scan over the events.
8152 * If we find an illegal name, return here, don't do anything.
8154 fname = find_end_event(arg, group != AUGROUP_ALL);
8155 if (fname == NULL)
8156 return FAIL;
8158 fname = skipwhite(fname);
8161 * Loop over the events.
8163 while (*arg && !vim_iswhite(*arg))
8164 if (apply_autocmds_group(event_name2nr(arg, &arg),
8165 fname, NULL, TRUE, group, curbuf, NULL))
8166 nothing_done = FALSE;
8168 if (nothing_done && do_msg)
8169 MSG(_("No matching autocommands"));
8171 #ifdef FEAT_EVAL
8172 return aborting() ? FAIL : OK;
8173 #else
8174 return OK;
8175 #endif
8179 * ":doautoall": execute autocommands for each loaded buffer.
8181 void
8182 ex_doautoall(eap)
8183 exarg_T *eap;
8185 int retval;
8186 aco_save_T aco;
8187 buf_T *buf;
8190 * This is a bit tricky: For some commands curwin->w_buffer needs to be
8191 * equal to curbuf, but for some buffers there may not be a window.
8192 * So we change the buffer for the current window for a moment. This
8193 * gives problems when the autocommands make changes to the list of
8194 * buffers or windows...
8196 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
8198 if (curbuf->b_ml.ml_mfp != NULL)
8200 /* find a window for this buffer and save some values */
8201 aucmd_prepbuf(&aco, buf);
8203 /* execute the autocommands for this buffer */
8204 retval = do_doautocmd(eap->arg, FALSE);
8206 /* Execute the modeline settings, but don't set window-local
8207 * options if we are using the current window for another buffer. */
8208 do_modelines(aco.save_curwin == NULL ? OPT_NOWIN : 0);
8210 /* restore the current window */
8211 aucmd_restbuf(&aco);
8213 /* stop if there is some error or buffer was deleted */
8214 if (retval == FAIL || !buf_valid(buf))
8215 break;
8219 check_cursor(); /* just in case lines got deleted */
8223 * Prepare for executing autocommands for (hidden) buffer "buf".
8224 * Search a window for the current buffer. Save the cursor position and
8225 * screen offset.
8226 * Set "curbuf" and "curwin" to match "buf".
8227 * When FEAT_AUTOCMD is not defined another version is used, see below.
8229 void
8230 aucmd_prepbuf(aco, buf)
8231 aco_save_T *aco; /* structure to save values in */
8232 buf_T *buf; /* new curbuf */
8234 win_T *win;
8236 aco->new_curbuf = buf;
8238 /* Find a window that is for the new buffer */
8239 if (buf == curbuf) /* be quick when buf is curbuf */
8240 win = curwin;
8241 else
8242 #ifdef FEAT_WINDOWS
8243 for (win = firstwin; win != NULL; win = win->w_next)
8244 if (win->w_buffer == buf)
8245 break;
8246 #else
8247 win = NULL;
8248 #endif
8251 * Prefer to use an existing window for the buffer, it has the least side
8252 * effects (esp. if "buf" is curbuf).
8253 * Otherwise, use curwin for "buf". It might make some items in the
8254 * window invalid. At least save the cursor and topline.
8256 if (win != NULL)
8258 /* there is a window for "buf", make it the curwin */
8259 aco->save_curwin = curwin;
8260 curwin = win;
8261 aco->save_buf = win->w_buffer;
8262 aco->new_curwin = win;
8264 else
8266 /* there is no window for "buf", use curwin */
8267 aco->save_curwin = NULL;
8268 aco->save_buf = curbuf;
8269 --curbuf->b_nwindows;
8270 curwin->w_buffer = buf;
8271 ++buf->b_nwindows;
8273 /* save cursor and topline, set them to safe values */
8274 aco->save_cursor = curwin->w_cursor;
8275 curwin->w_cursor.lnum = 1;
8276 curwin->w_cursor.col = 0;
8277 aco->save_topline = curwin->w_topline;
8278 curwin->w_topline = 1;
8279 #ifdef FEAT_DIFF
8280 aco->save_topfill = curwin->w_topfill;
8281 curwin->w_topfill = 0;
8282 #endif
8285 curbuf = buf;
8289 * Cleanup after executing autocommands for a (hidden) buffer.
8290 * Restore the window as it was (if possible).
8291 * When FEAT_AUTOCMD is not defined another version is used, see below.
8293 void
8294 aucmd_restbuf(aco)
8295 aco_save_T *aco; /* structure holding saved values */
8297 if (aco->save_curwin != NULL)
8299 /* restore curwin */
8300 #ifdef FEAT_WINDOWS
8301 if (win_valid(aco->save_curwin))
8302 #endif
8304 /* restore the buffer which was previously edited by curwin, if
8305 * it's still the same window and it's valid */
8306 if (curwin == aco->new_curwin
8307 && buf_valid(aco->save_buf)
8308 && aco->save_buf->b_ml.ml_mfp != NULL)
8310 --curbuf->b_nwindows;
8311 curbuf = aco->save_buf;
8312 curwin->w_buffer = curbuf;
8313 ++curbuf->b_nwindows;
8316 curwin = aco->save_curwin;
8317 curbuf = curwin->w_buffer;
8320 else
8322 /* restore buffer for curwin if it still exists and is loaded */
8323 if (buf_valid(aco->save_buf) && aco->save_buf->b_ml.ml_mfp != NULL)
8325 --curbuf->b_nwindows;
8326 curbuf = aco->save_buf;
8327 curwin->w_buffer = curbuf;
8328 ++curbuf->b_nwindows;
8329 curwin->w_cursor = aco->save_cursor;
8330 check_cursor();
8331 /* check topline < line_count, in case lines got deleted */
8332 if (aco->save_topline <= curbuf->b_ml.ml_line_count)
8334 curwin->w_topline = aco->save_topline;
8335 #ifdef FEAT_DIFF
8336 curwin->w_topfill = aco->save_topfill;
8337 #endif
8339 else
8341 curwin->w_topline = curbuf->b_ml.ml_line_count;
8342 #ifdef FEAT_DIFF
8343 curwin->w_topfill = 0;
8344 #endif
8350 static int autocmd_nested = FALSE;
8353 * Execute autocommands for "event" and file name "fname".
8354 * Return TRUE if some commands were executed.
8357 apply_autocmds(event, fname, fname_io, force, buf)
8358 event_T event;
8359 char_u *fname; /* NULL or empty means use actual file name */
8360 char_u *fname_io; /* fname to use for <afile> on cmdline */
8361 int force; /* when TRUE, ignore autocmd_busy */
8362 buf_T *buf; /* buffer for <abuf> */
8364 return apply_autocmds_group(event, fname, fname_io, force,
8365 AUGROUP_ALL, buf, NULL);
8369 * Like apply_autocmds(), but with extra "eap" argument. This takes care of
8370 * setting v:filearg.
8372 static int
8373 apply_autocmds_exarg(event, fname, fname_io, force, buf, eap)
8374 event_T event;
8375 char_u *fname;
8376 char_u *fname_io;
8377 int force;
8378 buf_T *buf;
8379 exarg_T *eap;
8381 return apply_autocmds_group(event, fname, fname_io, force,
8382 AUGROUP_ALL, buf, eap);
8386 * Like apply_autocmds(), but handles the caller's retval. If the script
8387 * processing is being aborted or if retval is FAIL when inside a try
8388 * conditional, no autocommands are executed. If otherwise the autocommands
8389 * cause the script to be aborted, retval is set to FAIL.
8392 apply_autocmds_retval(event, fname, fname_io, force, buf, retval)
8393 event_T event;
8394 char_u *fname; /* NULL or empty means use actual file name */
8395 char_u *fname_io; /* fname to use for <afile> on cmdline */
8396 int force; /* when TRUE, ignore autocmd_busy */
8397 buf_T *buf; /* buffer for <abuf> */
8398 int *retval; /* pointer to caller's retval */
8400 int did_cmd;
8402 #ifdef FEAT_EVAL
8403 if (should_abort(*retval))
8404 return FALSE;
8405 #endif
8407 did_cmd = apply_autocmds_group(event, fname, fname_io, force,
8408 AUGROUP_ALL, buf, NULL);
8409 if (did_cmd
8410 #ifdef FEAT_EVAL
8411 && aborting()
8412 #endif
8414 *retval = FAIL;
8415 return did_cmd;
8419 * Return TRUE when there is a CursorHold autocommand defined.
8422 has_cursorhold()
8424 return (first_autopat[(int)(get_real_state() == NORMAL_BUSY
8425 ? EVENT_CURSORHOLD : EVENT_CURSORHOLDI)] != NULL);
8429 * Return TRUE if the CursorHold event can be triggered.
8432 trigger_cursorhold()
8434 int state;
8436 if (!did_cursorhold && has_cursorhold() && !Recording
8437 #ifdef FEAT_INS_EXPAND
8438 && !ins_compl_active()
8439 #endif
8442 state = get_real_state();
8443 if (state == NORMAL_BUSY || (state & INSERT) != 0)
8444 return TRUE;
8446 return FALSE;
8450 * Return TRUE when there is a CursorMoved autocommand defined.
8453 has_cursormoved()
8455 return (first_autopat[(int)EVENT_CURSORMOVED] != NULL);
8459 * Return TRUE when there is a CursorMovedI autocommand defined.
8462 has_cursormovedI()
8464 return (first_autopat[(int)EVENT_CURSORMOVEDI] != NULL);
8467 static int
8468 apply_autocmds_group(event, fname, fname_io, force, group, buf, eap)
8469 event_T event;
8470 char_u *fname; /* NULL or empty means use actual file name */
8471 char_u *fname_io; /* fname to use for <afile> on cmdline, NULL means
8472 use fname */
8473 int force; /* when TRUE, ignore autocmd_busy */
8474 int group; /* group ID, or AUGROUP_ALL */
8475 buf_T *buf; /* buffer for <abuf> */
8476 exarg_T *eap; /* command arguments */
8478 char_u *sfname = NULL; /* short file name */
8479 char_u *tail;
8480 int save_changed;
8481 buf_T *old_curbuf;
8482 int retval = FALSE;
8483 char_u *save_sourcing_name;
8484 linenr_T save_sourcing_lnum;
8485 char_u *save_autocmd_fname;
8486 int save_autocmd_bufnr;
8487 char_u *save_autocmd_match;
8488 int save_autocmd_busy;
8489 int save_autocmd_nested;
8490 static int nesting = 0;
8491 AutoPatCmd patcmd;
8492 AutoPat *ap;
8493 #ifdef FEAT_EVAL
8494 scid_T save_current_SID;
8495 void *save_funccalp;
8496 char_u *save_cmdarg;
8497 long save_cmdbang;
8498 #endif
8499 static int filechangeshell_busy = FALSE;
8500 #ifdef FEAT_PROFILE
8501 proftime_T wait_time;
8502 #endif
8505 * Quickly return if there are no autocommands for this event or
8506 * autocommands are blocked.
8508 if (first_autopat[(int)event] == NULL || autocmd_blocked > 0)
8509 goto BYPASS_AU;
8512 * When autocommands are busy, new autocommands are only executed when
8513 * explicitly enabled with the "nested" flag.
8515 if (autocmd_busy && !(force || autocmd_nested))
8516 goto BYPASS_AU;
8518 #ifdef FEAT_EVAL
8520 * Quickly return when immediately aborting on error, or when an interrupt
8521 * occurred or an exception was thrown but not caught.
8523 if (aborting())
8524 goto BYPASS_AU;
8525 #endif
8528 * FileChangedShell never nests, because it can create an endless loop.
8530 if (filechangeshell_busy && (event == EVENT_FILECHANGEDSHELL
8531 || event == EVENT_FILECHANGEDSHELLPOST))
8532 goto BYPASS_AU;
8535 * Ignore events in 'eventignore'.
8537 if (event_ignored(event))
8538 goto BYPASS_AU;
8541 * Allow nesting of autocommands, but restrict the depth, because it's
8542 * possible to create an endless loop.
8544 if (nesting == 10)
8546 EMSG(_("E218: autocommand nesting too deep"));
8547 goto BYPASS_AU;
8551 * Check if these autocommands are disabled. Used when doing ":all" or
8552 * ":ball".
8554 if ( (autocmd_no_enter
8555 && (event == EVENT_WINENTER || event == EVENT_BUFENTER))
8556 || (autocmd_no_leave
8557 && (event == EVENT_WINLEAVE || event == EVENT_BUFLEAVE)))
8558 goto BYPASS_AU;
8561 * Save the autocmd_* variables and info about the current buffer.
8563 save_autocmd_fname = autocmd_fname;
8564 save_autocmd_bufnr = autocmd_bufnr;
8565 save_autocmd_match = autocmd_match;
8566 save_autocmd_busy = autocmd_busy;
8567 save_autocmd_nested = autocmd_nested;
8568 save_changed = curbuf->b_changed;
8569 old_curbuf = curbuf;
8572 * Set the file name to be used for <afile>.
8573 * Make a copy to avoid that changing a buffer name or directory makes it
8574 * invalid.
8576 if (fname_io == NULL)
8578 if (fname != NULL && *fname != NUL)
8579 autocmd_fname = fname;
8580 else if (buf != NULL)
8581 autocmd_fname = buf->b_fname;
8582 else
8583 autocmd_fname = NULL;
8585 else
8586 autocmd_fname = fname_io;
8587 if (autocmd_fname != NULL)
8588 autocmd_fname = FullName_save(autocmd_fname, FALSE);
8591 * Set the buffer number to be used for <abuf>.
8593 if (buf == NULL)
8594 autocmd_bufnr = 0;
8595 else
8596 autocmd_bufnr = buf->b_fnum;
8599 * When the file name is NULL or empty, use the file name of buffer "buf".
8600 * Always use the full path of the file name to match with, in case
8601 * "allow_dirs" is set.
8603 if (fname == NULL || *fname == NUL)
8605 if (buf == NULL)
8606 fname = NULL;
8607 else
8609 #ifdef FEAT_SYN_HL
8610 if (event == EVENT_SYNTAX)
8611 fname = buf->b_p_syn;
8612 else
8613 #endif
8614 if (event == EVENT_FILETYPE)
8615 fname = buf->b_p_ft;
8616 else
8618 if (buf->b_sfname != NULL)
8619 sfname = vim_strsave(buf->b_sfname);
8620 fname = buf->b_ffname;
8623 if (fname == NULL)
8624 fname = (char_u *)"";
8625 fname = vim_strsave(fname); /* make a copy, so we can change it */
8627 else
8629 sfname = vim_strsave(fname);
8630 /* Don't try expanding FileType, Syntax, WindowID or QuickFixCmd* */
8631 if (event == EVENT_FILETYPE
8632 || event == EVENT_SYNTAX
8633 || event == EVENT_REMOTEREPLY
8634 || event == EVENT_SPELLFILEMISSING
8635 || event == EVENT_QUICKFIXCMDPRE
8636 || event == EVENT_QUICKFIXCMDPOST)
8637 fname = vim_strsave(fname);
8638 else
8639 fname = FullName_save(fname, FALSE);
8641 if (fname == NULL) /* out of memory */
8643 vim_free(sfname);
8644 retval = FALSE;
8645 goto BYPASS_AU;
8648 #ifdef BACKSLASH_IN_FILENAME
8650 * Replace all backslashes with forward slashes. This makes the
8651 * autocommand patterns portable between Unix and MS-DOS.
8653 if (sfname != NULL)
8654 forward_slash(sfname);
8655 forward_slash(fname);
8656 #endif
8658 #ifdef VMS
8659 /* remove version for correct match */
8660 if (sfname != NULL)
8661 vms_remove_version(sfname);
8662 vms_remove_version(fname);
8663 #endif
8666 * Set the name to be used for <amatch>.
8668 autocmd_match = fname;
8671 /* Don't redraw while doing auto commands. */
8672 ++RedrawingDisabled;
8673 save_sourcing_name = sourcing_name;
8674 sourcing_name = NULL; /* don't free this one */
8675 save_sourcing_lnum = sourcing_lnum;
8676 sourcing_lnum = 0; /* no line number here */
8678 #ifdef FEAT_EVAL
8679 save_current_SID = current_SID;
8681 # ifdef FEAT_PROFILE
8682 if (do_profiling == PROF_YES)
8683 prof_child_enter(&wait_time); /* doesn't count for the caller itself */
8684 # endif
8686 /* Don't use local function variables, if called from a function */
8687 save_funccalp = save_funccal();
8688 #endif
8691 * When starting to execute autocommands, save the search patterns.
8693 if (!autocmd_busy)
8695 save_search_patterns();
8696 saveRedobuff();
8697 did_filetype = keep_filetype;
8701 * Note that we are applying autocmds. Some commands need to know.
8703 autocmd_busy = TRUE;
8704 filechangeshell_busy = (event == EVENT_FILECHANGEDSHELL);
8705 ++nesting; /* see matching decrement below */
8707 /* Remember that FileType was triggered. Used for did_filetype(). */
8708 if (event == EVENT_FILETYPE)
8709 did_filetype = TRUE;
8711 tail = gettail(fname);
8713 /* Find first autocommand that matches */
8714 patcmd.curpat = first_autopat[(int)event];
8715 patcmd.nextcmd = NULL;
8716 patcmd.group = group;
8717 patcmd.fname = fname;
8718 patcmd.sfname = sfname;
8719 patcmd.tail = tail;
8720 patcmd.event = event;
8721 patcmd.arg_bufnr = autocmd_bufnr;
8722 patcmd.next = NULL;
8723 auto_next_pat(&patcmd, FALSE);
8725 /* found one, start executing the autocommands */
8726 if (patcmd.curpat != NULL)
8728 /* add to active_apc_list */
8729 patcmd.next = active_apc_list;
8730 active_apc_list = &patcmd;
8732 #ifdef FEAT_EVAL
8733 /* set v:cmdarg (only when there is a matching pattern) */
8734 save_cmdbang = get_vim_var_nr(VV_CMDBANG);
8735 if (eap != NULL)
8737 save_cmdarg = set_cmdarg(eap, NULL);
8738 set_vim_var_nr(VV_CMDBANG, (long)eap->forceit);
8740 else
8741 save_cmdarg = NULL; /* avoid gcc warning */
8742 #endif
8743 retval = TRUE;
8744 /* mark the last pattern, to avoid an endless loop when more patterns
8745 * are added when executing autocommands */
8746 for (ap = patcmd.curpat; ap->next != NULL; ap = ap->next)
8747 ap->last = FALSE;
8748 ap->last = TRUE;
8749 check_lnums(TRUE); /* make sure cursor and topline are valid */
8750 do_cmdline(NULL, getnextac, (void *)&patcmd,
8751 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT);
8752 #ifdef FEAT_EVAL
8753 if (eap != NULL)
8755 (void)set_cmdarg(NULL, save_cmdarg);
8756 set_vim_var_nr(VV_CMDBANG, save_cmdbang);
8758 #endif
8759 /* delete from active_apc_list */
8760 if (active_apc_list == &patcmd) /* just in case */
8761 active_apc_list = patcmd.next;
8764 --RedrawingDisabled;
8765 autocmd_busy = save_autocmd_busy;
8766 filechangeshell_busy = FALSE;
8767 autocmd_nested = save_autocmd_nested;
8768 vim_free(sourcing_name);
8769 sourcing_name = save_sourcing_name;
8770 sourcing_lnum = save_sourcing_lnum;
8771 vim_free(autocmd_fname);
8772 autocmd_fname = save_autocmd_fname;
8773 autocmd_bufnr = save_autocmd_bufnr;
8774 autocmd_match = save_autocmd_match;
8775 #ifdef FEAT_EVAL
8776 current_SID = save_current_SID;
8777 restore_funccal(save_funccalp);
8778 # ifdef FEAT_PROFILE
8779 if (do_profiling == PROF_YES)
8780 prof_child_exit(&wait_time);
8781 # endif
8782 #endif
8783 vim_free(fname);
8784 vim_free(sfname);
8785 --nesting; /* see matching increment above */
8788 * When stopping to execute autocommands, restore the search patterns and
8789 * the redo buffer.
8791 if (!autocmd_busy)
8793 restore_search_patterns();
8794 restoreRedobuff();
8795 did_filetype = FALSE;
8799 * Some events don't set or reset the Changed flag.
8800 * Check if still in the same buffer!
8802 if (curbuf == old_curbuf
8803 && (event == EVENT_BUFREADPOST
8804 || event == EVENT_BUFWRITEPOST
8805 || event == EVENT_FILEAPPENDPOST
8806 || event == EVENT_VIMLEAVE
8807 || event == EVENT_VIMLEAVEPRE))
8809 #ifdef FEAT_TITLE
8810 if (curbuf->b_changed != save_changed)
8811 need_maketitle = TRUE;
8812 #endif
8813 curbuf->b_changed = save_changed;
8816 au_cleanup(); /* may really delete removed patterns/commands now */
8818 BYPASS_AU:
8819 /* When wiping out a buffer make sure all its buffer-local autocommands
8820 * are deleted. */
8821 if (event == EVENT_BUFWIPEOUT && buf != NULL)
8822 aubuflocal_remove(buf);
8824 return retval;
8827 # ifdef FEAT_EVAL
8828 static char_u *old_termresponse = NULL;
8829 # endif
8832 * Block triggering autocommands until unblock_autocmd() is called.
8833 * Can be used recursively, so long as it's symmetric.
8835 void
8836 block_autocmds()
8838 # ifdef FEAT_EVAL
8839 /* Remember the value of v:termresponse. */
8840 if (autocmd_blocked == 0)
8841 old_termresponse = get_vim_var_str(VV_TERMRESPONSE);
8842 # endif
8843 ++autocmd_blocked;
8846 void
8847 unblock_autocmds()
8849 --autocmd_blocked;
8851 # ifdef FEAT_EVAL
8852 /* When v:termresponse was set while autocommands were blocked, trigger
8853 * the autocommands now. Esp. useful when executing a shell command
8854 * during startup (vimdiff). */
8855 if (autocmd_blocked == 0
8856 && get_vim_var_str(VV_TERMRESPONSE) != old_termresponse)
8857 apply_autocmds(EVENT_TERMRESPONSE, NULL, NULL, FALSE, curbuf);
8858 # endif
8862 * Find next autocommand pattern that matches.
8864 static void
8865 auto_next_pat(apc, stop_at_last)
8866 AutoPatCmd *apc;
8867 int stop_at_last; /* stop when 'last' flag is set */
8869 AutoPat *ap;
8870 AutoCmd *cp;
8871 char_u *name;
8872 char *s;
8874 vim_free(sourcing_name);
8875 sourcing_name = NULL;
8877 for (ap = apc->curpat; ap != NULL && !got_int; ap = ap->next)
8879 apc->curpat = NULL;
8881 /* only use a pattern when it has not been removed, has commands and
8882 * the group matches. For buffer-local autocommands only check the
8883 * buffer number. */
8884 if (ap->pat != NULL && ap->cmds != NULL
8885 && (apc->group == AUGROUP_ALL || apc->group == ap->group))
8887 /* execution-condition */
8888 if (ap->buflocal_nr == 0
8889 ? (match_file_pat(NULL, ap->reg_prog, apc->fname,
8890 apc->sfname, apc->tail, ap->allow_dirs))
8891 : ap->buflocal_nr == apc->arg_bufnr)
8893 name = event_nr2name(apc->event);
8894 s = _("%s Auto commands for \"%s\"");
8895 sourcing_name = alloc((unsigned)(STRLEN(s)
8896 + STRLEN(name) + ap->patlen + 1));
8897 if (sourcing_name != NULL)
8899 sprintf((char *)sourcing_name, s,
8900 (char *)name, (char *)ap->pat);
8901 if (p_verbose >= 8)
8903 verbose_enter();
8904 smsg((char_u *)_("Executing %s"), sourcing_name);
8905 verbose_leave();
8909 apc->curpat = ap;
8910 apc->nextcmd = ap->cmds;
8911 /* mark last command */
8912 for (cp = ap->cmds; cp->next != NULL; cp = cp->next)
8913 cp->last = FALSE;
8914 cp->last = TRUE;
8916 line_breakcheck();
8917 if (apc->curpat != NULL) /* found a match */
8918 break;
8920 if (stop_at_last && ap->last)
8921 break;
8926 * Get next autocommand command.
8927 * Called by do_cmdline() to get the next line for ":if".
8928 * Returns allocated string, or NULL for end of autocommands.
8930 /* ARGSUSED */
8931 static char_u *
8932 getnextac(c, cookie, indent)
8933 int c; /* not used */
8934 void *cookie;
8935 int indent; /* not used */
8937 AutoPatCmd *acp = (AutoPatCmd *)cookie;
8938 char_u *retval;
8939 AutoCmd *ac;
8941 /* Can be called again after returning the last line. */
8942 if (acp->curpat == NULL)
8943 return NULL;
8945 /* repeat until we find an autocommand to execute */
8946 for (;;)
8948 /* skip removed commands */
8949 while (acp->nextcmd != NULL && acp->nextcmd->cmd == NULL)
8950 if (acp->nextcmd->last)
8951 acp->nextcmd = NULL;
8952 else
8953 acp->nextcmd = acp->nextcmd->next;
8955 if (acp->nextcmd != NULL)
8956 break;
8958 /* at end of commands, find next pattern that matches */
8959 if (acp->curpat->last)
8960 acp->curpat = NULL;
8961 else
8962 acp->curpat = acp->curpat->next;
8963 if (acp->curpat != NULL)
8964 auto_next_pat(acp, TRUE);
8965 if (acp->curpat == NULL)
8966 return NULL;
8969 ac = acp->nextcmd;
8971 if (p_verbose >= 9)
8973 verbose_enter_scroll();
8974 smsg((char_u *)_("autocommand %s"), ac->cmd);
8975 msg_puts((char_u *)"\n"); /* don't overwrite this either */
8976 verbose_leave_scroll();
8978 retval = vim_strsave(ac->cmd);
8979 autocmd_nested = ac->nested;
8980 #ifdef FEAT_EVAL
8981 current_SID = ac->scriptID;
8982 #endif
8983 if (ac->last)
8984 acp->nextcmd = NULL;
8985 else
8986 acp->nextcmd = ac->next;
8987 return retval;
8991 * Return TRUE if there is a matching autocommand for "fname".
8992 * To account for buffer-local autocommands, function needs to know
8993 * in which buffer the file will be opened.
8996 has_autocmd(event, sfname, buf)
8997 event_T event;
8998 char_u *sfname;
8999 buf_T *buf;
9001 AutoPat *ap;
9002 char_u *fname;
9003 char_u *tail = gettail(sfname);
9004 int retval = FALSE;
9006 fname = FullName_save(sfname, FALSE);
9007 if (fname == NULL)
9008 return FALSE;
9010 #ifdef BACKSLASH_IN_FILENAME
9012 * Replace all backslashes with forward slashes. This makes the
9013 * autocommand patterns portable between Unix and MS-DOS.
9015 sfname = vim_strsave(sfname);
9016 if (sfname != NULL)
9017 forward_slash(sfname);
9018 forward_slash(fname);
9019 #endif
9021 for (ap = first_autopat[(int)event]; ap != NULL; ap = ap->next)
9022 if (ap->pat != NULL && ap->cmds != NULL
9023 && (ap->buflocal_nr == 0
9024 ? match_file_pat(NULL, ap->reg_prog,
9025 fname, sfname, tail, ap->allow_dirs)
9026 : buf != NULL && ap->buflocal_nr == buf->b_fnum
9029 retval = TRUE;
9030 break;
9033 vim_free(fname);
9034 #ifdef BACKSLASH_IN_FILENAME
9035 vim_free(sfname);
9036 #endif
9038 return retval;
9041 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
9043 * Function given to ExpandGeneric() to obtain the list of autocommand group
9044 * names.
9046 /*ARGSUSED*/
9047 char_u *
9048 get_augroup_name(xp, idx)
9049 expand_T *xp;
9050 int idx;
9052 if (idx == augroups.ga_len) /* add "END" add the end */
9053 return (char_u *)"END";
9054 if (idx >= augroups.ga_len) /* end of list */
9055 return NULL;
9056 if (AUGROUP_NAME(idx) == NULL) /* skip deleted entries */
9057 return (char_u *)"";
9058 return AUGROUP_NAME(idx); /* return a name */
9061 static int include_groups = FALSE;
9063 char_u *
9064 set_context_in_autocmd(xp, arg, doautocmd)
9065 expand_T *xp;
9066 char_u *arg;
9067 int doautocmd; /* TRUE for :doautocmd, FALSE for :autocmd */
9069 char_u *p;
9070 int group;
9072 /* check for a group name, skip it if present */
9073 include_groups = FALSE;
9074 p = arg;
9075 group = au_get_grouparg(&arg);
9076 if (group == AUGROUP_ERROR)
9077 return NULL;
9078 /* If there only is a group name that's what we expand. */
9079 if (*arg == NUL && group != AUGROUP_ALL && !vim_iswhite(arg[-1]))
9081 arg = p;
9082 group = AUGROUP_ALL;
9085 /* skip over event name */
9086 for (p = arg; *p != NUL && !vim_iswhite(*p); ++p)
9087 if (*p == ',')
9088 arg = p + 1;
9089 if (*p == NUL)
9091 if (group == AUGROUP_ALL)
9092 include_groups = TRUE;
9093 xp->xp_context = EXPAND_EVENTS; /* expand event name */
9094 xp->xp_pattern = arg;
9095 return NULL;
9098 /* skip over pattern */
9099 arg = skipwhite(p);
9100 while (*arg && (!vim_iswhite(*arg) || arg[-1] == '\\'))
9101 arg++;
9102 if (*arg)
9103 return arg; /* expand (next) command */
9105 if (doautocmd)
9106 xp->xp_context = EXPAND_FILES; /* expand file names */
9107 else
9108 xp->xp_context = EXPAND_NOTHING; /* pattern is not expanded */
9109 return NULL;
9113 * Function given to ExpandGeneric() to obtain the list of event names.
9115 /*ARGSUSED*/
9116 char_u *
9117 get_event_name(xp, idx)
9118 expand_T *xp;
9119 int idx;
9121 if (idx < augroups.ga_len) /* First list group names, if wanted */
9123 if (!include_groups || AUGROUP_NAME(idx) == NULL)
9124 return (char_u *)""; /* skip deleted entries */
9125 return AUGROUP_NAME(idx); /* return a name */
9127 return (char_u *)event_names[idx - augroups.ga_len].name;
9130 #endif /* FEAT_CMDL_COMPL */
9133 * Return TRUE if autocmd is supported.
9136 autocmd_supported(name)
9137 char_u *name;
9139 char_u *p;
9141 return (event_name2nr(name, &p) != NUM_EVENTS);
9145 * Return TRUE if an autocommand is defined for a group, event and
9146 * pattern: The group can be omitted to accept any group. "event" and "pattern"
9147 * can be NULL to accept any event and pattern. "pattern" can be NULL to accept
9148 * any pattern. Buffer-local patterns <buffer> or <buffer=N> are accepted.
9149 * Used for:
9150 * exists("#Group") or
9151 * exists("#Group#Event") or
9152 * exists("#Group#Event#pat") or
9153 * exists("#Event") or
9154 * exists("#Event#pat")
9157 au_exists(arg)
9158 char_u *arg;
9160 char_u *arg_save;
9161 char_u *pattern = NULL;
9162 char_u *event_name;
9163 char_u *p;
9164 event_T event;
9165 AutoPat *ap;
9166 buf_T *buflocal_buf = NULL;
9167 int group;
9168 int retval = FALSE;
9170 /* Make a copy so that we can change the '#' chars to a NUL. */
9171 arg_save = vim_strsave(arg);
9172 if (arg_save == NULL)
9173 return FALSE;
9174 p = vim_strchr(arg_save, '#');
9175 if (p != NULL)
9176 *p++ = NUL;
9178 /* First, look for an autocmd group name */
9179 group = au_find_group(arg_save);
9180 if (group == AUGROUP_ERROR)
9182 /* Didn't match a group name, assume the first argument is an event. */
9183 group = AUGROUP_ALL;
9184 event_name = arg_save;
9186 else
9188 if (p == NULL)
9190 /* "Group": group name is present and it's recognized */
9191 retval = TRUE;
9192 goto theend;
9195 /* Must be "Group#Event" or "Group#Event#pat". */
9196 event_name = p;
9197 p = vim_strchr(event_name, '#');
9198 if (p != NULL)
9199 *p++ = NUL; /* "Group#Event#pat" */
9202 pattern = p; /* "pattern" is NULL when there is no pattern */
9204 /* find the index (enum) for the event name */
9205 event = event_name2nr(event_name, &p);
9207 /* return FALSE if the event name is not recognized */
9208 if (event == NUM_EVENTS)
9209 goto theend;
9211 /* Find the first autocommand for this event.
9212 * If there isn't any, return FALSE;
9213 * If there is one and no pattern given, return TRUE; */
9214 ap = first_autopat[(int)event];
9215 if (ap == NULL)
9216 goto theend;
9217 if (pattern == NULL)
9219 retval = TRUE;
9220 goto theend;
9223 /* if pattern is "<buffer>", special handling is needed which uses curbuf */
9224 /* for pattern "<buffer=N>, fnamecmp() will work fine */
9225 if (STRICMP(pattern, "<buffer>") == 0)
9226 buflocal_buf = curbuf;
9228 /* Check if there is an autocommand with the given pattern. */
9229 for ( ; ap != NULL; ap = ap->next)
9230 /* only use a pattern when it has not been removed and has commands. */
9231 /* For buffer-local autocommands, fnamecmp() works fine. */
9232 if (ap->pat != NULL && ap->cmds != NULL
9233 && (group == AUGROUP_ALL || ap->group == group)
9234 && (buflocal_buf == NULL
9235 ? fnamecmp(ap->pat, pattern) == 0
9236 : ap->buflocal_nr == buflocal_buf->b_fnum))
9238 retval = TRUE;
9239 break;
9242 theend:
9243 vim_free(arg_save);
9244 return retval;
9247 #else /* FEAT_AUTOCMD */
9250 * Prepare for executing commands for (hidden) buffer "buf".
9251 * This is the non-autocommand version, it simply saves "curbuf" and sets
9252 * "curbuf" and "curwin" to match "buf".
9254 void
9255 aucmd_prepbuf(aco, buf)
9256 aco_save_T *aco; /* structure to save values in */
9257 buf_T *buf; /* new curbuf */
9259 aco->save_buf = curbuf;
9260 curbuf = buf;
9261 curwin->w_buffer = buf;
9265 * Restore after executing commands for a (hidden) buffer.
9266 * This is the non-autocommand version.
9268 void
9269 aucmd_restbuf(aco)
9270 aco_save_T *aco; /* structure holding saved values */
9272 curbuf = aco->save_buf;
9273 curwin->w_buffer = curbuf;
9276 #endif /* FEAT_AUTOCMD */
9279 #if defined(FEAT_AUTOCMD) || defined(FEAT_WILDIGN) || defined(PROTO)
9281 * Try matching a filename with a "pattern" ("prog" is NULL), or use the
9282 * precompiled regprog "prog" ("pattern" is NULL). That avoids calling
9283 * vim_regcomp() often.
9284 * Used for autocommands and 'wildignore'.
9285 * Returns TRUE if there is a match, FALSE otherwise.
9288 match_file_pat(pattern, prog, fname, sfname, tail, allow_dirs)
9289 char_u *pattern; /* pattern to match with */
9290 regprog_T *prog; /* pre-compiled regprog or NULL */
9291 char_u *fname; /* full path of file name */
9292 char_u *sfname; /* short file name or NULL */
9293 char_u *tail; /* tail of path */
9294 int allow_dirs; /* allow matching with dir */
9296 regmatch_T regmatch;
9297 int result = FALSE;
9298 #ifdef FEAT_OSFILETYPE
9299 int no_pattern = FALSE; /* TRUE if check is filetype only */
9300 char_u *type_start;
9301 char_u c;
9302 int match = FALSE;
9303 #endif
9305 #ifdef CASE_INSENSITIVE_FILENAME
9306 regmatch.rm_ic = TRUE; /* Always ignore case */
9307 #else
9308 regmatch.rm_ic = FALSE; /* Don't ever ignore case */
9309 #endif
9310 #ifdef FEAT_OSFILETYPE
9311 if (*pattern == '<')
9313 /* There is a filetype condition specified with this pattern.
9314 * Check the filetype matches first. If not, don't bother with the
9315 * pattern (set regprog to NULL).
9316 * Always use magic for the regexp.
9319 for (type_start = pattern + 1; (c = *pattern); pattern++)
9321 if ((c == ';' || c == '>') && match == FALSE)
9323 *pattern = NUL; /* Terminate the string */
9324 match = mch_check_filetype(fname, type_start);
9325 *pattern = c; /* Restore the terminator */
9326 type_start = pattern + 1;
9328 if (c == '>')
9329 break;
9332 /* (c should never be NUL, but check anyway) */
9333 if (match == FALSE || c == NUL)
9334 regmatch.regprog = NULL; /* Doesn't match - don't check pat. */
9335 else if (*pattern == NUL)
9337 regmatch.regprog = NULL; /* Vim will try to free regprog later */
9338 no_pattern = TRUE; /* Always matches - don't check pat. */
9340 else
9341 regmatch.regprog = vim_regcomp(pattern + 1, RE_MAGIC);
9343 else
9344 #endif
9346 if (prog != NULL)
9347 regmatch.regprog = prog;
9348 else
9349 regmatch.regprog = vim_regcomp(pattern, RE_MAGIC);
9353 * Try for a match with the pattern with:
9354 * 1. the full file name, when the pattern has a '/'.
9355 * 2. the short file name, when the pattern has a '/'.
9356 * 3. the tail of the file name, when the pattern has no '/'.
9358 if (
9359 #ifdef FEAT_OSFILETYPE
9360 /* If the check is for a filetype only and we don't care
9361 * about the path then skip all the regexp stuff.
9363 no_pattern ||
9364 #endif
9365 (regmatch.regprog != NULL
9366 && ((allow_dirs
9367 && (vim_regexec(&regmatch, fname, (colnr_T)0)
9368 || (sfname != NULL
9369 && vim_regexec(&regmatch, sfname, (colnr_T)0))))
9370 || (!allow_dirs && vim_regexec(&regmatch, tail, (colnr_T)0)))))
9371 result = TRUE;
9373 if (prog == NULL)
9374 vim_free(regmatch.regprog);
9375 return result;
9377 #endif
9379 #if defined(FEAT_WILDIGN) || defined(PROTO)
9381 * Return TRUE if a file matches with a pattern in "list".
9382 * "list" is a comma-separated list of patterns, like 'wildignore'.
9383 * "sfname" is the short file name or NULL, "ffname" the long file name.
9386 match_file_list(list, sfname, ffname)
9387 char_u *list;
9388 char_u *sfname;
9389 char_u *ffname;
9391 char_u buf[100];
9392 char_u *tail;
9393 char_u *regpat;
9394 char allow_dirs;
9395 int match;
9396 char_u *p;
9398 tail = gettail(sfname);
9400 /* try all patterns in 'wildignore' */
9401 p = list;
9402 while (*p)
9404 copy_option_part(&p, buf, 100, ",");
9405 regpat = file_pat_to_reg_pat(buf, NULL, &allow_dirs, FALSE);
9406 if (regpat == NULL)
9407 break;
9408 match = match_file_pat(regpat, NULL, ffname, sfname,
9409 tail, (int)allow_dirs);
9410 vim_free(regpat);
9411 if (match)
9412 return TRUE;
9414 return FALSE;
9416 #endif
9419 * Convert the given pattern "pat" which has shell style wildcards in it, into
9420 * a regular expression, and return the result in allocated memory. If there
9421 * is a directory path separator to be matched, then TRUE is put in
9422 * allow_dirs, otherwise FALSE is put there -- webb.
9423 * Handle backslashes before special characters, like "\*" and "\ ".
9425 * If FEAT_OSFILETYPE defined then pass initial <type> through unchanged. Eg:
9426 * '<html>myfile' becomes '<html>^myfile$' -- leonard.
9428 * Returns NULL when out of memory.
9430 /*ARGSUSED*/
9431 char_u *
9432 file_pat_to_reg_pat(pat, pat_end, allow_dirs, no_bslash)
9433 char_u *pat;
9434 char_u *pat_end; /* first char after pattern or NULL */
9435 char *allow_dirs; /* Result passed back out in here */
9436 int no_bslash; /* Don't use a backward slash as pathsep */
9438 int size;
9439 char_u *endp;
9440 char_u *reg_pat;
9441 char_u *p;
9442 int i;
9443 int nested = 0;
9444 int add_dollar = TRUE;
9445 #ifdef FEAT_OSFILETYPE
9446 int check_length = 0;
9447 #endif
9449 if (allow_dirs != NULL)
9450 *allow_dirs = FALSE;
9451 if (pat_end == NULL)
9452 pat_end = pat + STRLEN(pat);
9454 #ifdef FEAT_OSFILETYPE
9455 /* Find out how much of the string is the filetype check */
9456 if (*pat == '<')
9458 /* Count chars until the next '>' */
9459 for (p = pat + 1; p < pat_end && *p != '>'; p++)
9461 if (p < pat_end)
9463 /* Pattern is of the form <.*>.* */
9464 check_length = p - pat + 1;
9465 if (p + 1 >= pat_end)
9467 /* The 'pattern' is a filetype check ONLY */
9468 reg_pat = (char_u *)alloc(check_length + 1);
9469 if (reg_pat != NULL)
9471 mch_memmove(reg_pat, pat, (size_t)check_length);
9472 reg_pat[check_length] = NUL;
9474 return reg_pat;
9477 /* else: there was no closing '>' - assume it was a normal pattern */
9480 pat += check_length;
9481 size = 2 + check_length;
9482 #else
9483 size = 2; /* '^' at start, '$' at end */
9484 #endif
9486 for (p = pat; p < pat_end; p++)
9488 switch (*p)
9490 case '*':
9491 case '.':
9492 case ',':
9493 case '{':
9494 case '}':
9495 case '~':
9496 size += 2; /* extra backslash */
9497 break;
9498 #ifdef BACKSLASH_IN_FILENAME
9499 case '\\':
9500 case '/':
9501 size += 4; /* could become "[\/]" */
9502 break;
9503 #endif
9504 default:
9505 size++;
9506 # ifdef FEAT_MBYTE
9507 if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
9509 ++p;
9510 ++size;
9512 # endif
9513 break;
9516 reg_pat = alloc(size + 1);
9517 if (reg_pat == NULL)
9518 return NULL;
9520 #ifdef FEAT_OSFILETYPE
9521 /* Copy the type check in to the start. */
9522 if (check_length)
9523 mch_memmove(reg_pat, pat - check_length, (size_t)check_length);
9524 i = check_length;
9525 #else
9526 i = 0;
9527 #endif
9529 if (pat[0] == '*')
9530 while (pat[0] == '*' && pat < pat_end - 1)
9531 pat++;
9532 else
9533 reg_pat[i++] = '^';
9534 endp = pat_end - 1;
9535 if (*endp == '*')
9537 while (endp - pat > 0 && *endp == '*')
9538 endp--;
9539 add_dollar = FALSE;
9541 for (p = pat; *p && nested >= 0 && p <= endp; p++)
9543 switch (*p)
9545 case '*':
9546 reg_pat[i++] = '.';
9547 reg_pat[i++] = '*';
9548 while (p[1] == '*') /* "**" matches like "*" */
9549 ++p;
9550 break;
9551 case '.':
9552 #ifdef RISCOS
9553 if (allow_dirs != NULL)
9554 *allow_dirs = TRUE;
9555 /* FALLTHROUGH */
9556 #endif
9557 case '~':
9558 reg_pat[i++] = '\\';
9559 reg_pat[i++] = *p;
9560 break;
9561 case '?':
9562 #ifdef RISCOS
9563 case '#':
9564 #endif
9565 reg_pat[i++] = '.';
9566 break;
9567 case '\\':
9568 if (p[1] == NUL)
9569 break;
9570 #ifdef BACKSLASH_IN_FILENAME
9571 if (!no_bslash)
9573 /* translate:
9574 * "\x" to "\\x" e.g., "dir\file"
9575 * "\*" to "\\.*" e.g., "dir\*.c"
9576 * "\?" to "\\." e.g., "dir\??.c"
9577 * "\+" to "\+" e.g., "fileX\+.c"
9579 if ((vim_isfilec(p[1]) || p[1] == '*' || p[1] == '?')
9580 && p[1] != '+')
9582 reg_pat[i++] = '[';
9583 reg_pat[i++] = '\\';
9584 reg_pat[i++] = '/';
9585 reg_pat[i++] = ']';
9586 if (allow_dirs != NULL)
9587 *allow_dirs = TRUE;
9588 break;
9591 #endif
9592 if (*++p == '?'
9593 #ifdef BACKSLASH_IN_FILENAME
9594 && no_bslash
9595 #endif
9597 reg_pat[i++] = '?';
9598 else
9599 if (*p == ',')
9600 reg_pat[i++] = ',';
9601 else
9603 if (allow_dirs != NULL && vim_ispathsep(*p)
9604 #ifdef BACKSLASH_IN_FILENAME
9605 && (!no_bslash || *p != '\\')
9606 #endif
9608 *allow_dirs = TRUE;
9609 reg_pat[i++] = '\\';
9610 reg_pat[i++] = *p;
9612 break;
9613 #ifdef BACKSLASH_IN_FILENAME
9614 case '/':
9615 reg_pat[i++] = '[';
9616 reg_pat[i++] = '\\';
9617 reg_pat[i++] = '/';
9618 reg_pat[i++] = ']';
9619 if (allow_dirs != NULL)
9620 *allow_dirs = TRUE;
9621 break;
9622 #endif
9623 case '{':
9624 reg_pat[i++] = '\\';
9625 reg_pat[i++] = '(';
9626 nested++;
9627 break;
9628 case '}':
9629 reg_pat[i++] = '\\';
9630 reg_pat[i++] = ')';
9631 --nested;
9632 break;
9633 case ',':
9634 if (nested)
9636 reg_pat[i++] = '\\';
9637 reg_pat[i++] = '|';
9639 else
9640 reg_pat[i++] = ',';
9641 break;
9642 default:
9643 # ifdef FEAT_MBYTE
9644 if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
9645 reg_pat[i++] = *p++;
9646 else
9647 # endif
9648 if (allow_dirs != NULL && vim_ispathsep(*p))
9649 *allow_dirs = TRUE;
9650 reg_pat[i++] = *p;
9651 break;
9654 if (add_dollar)
9655 reg_pat[i++] = '$';
9656 reg_pat[i] = NUL;
9657 if (nested != 0)
9659 if (nested < 0)
9660 EMSG(_("E219: Missing {."));
9661 else
9662 EMSG(_("E220: Missing }."));
9663 vim_free(reg_pat);
9664 reg_pat = NULL;
9666 return reg_pat;