Merged from the latest developing branch.
[MacVim.git] / src / fileio.c
blobf6a4da791ff38cc654589d921966d2b131c12e68
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 set_options = newfile || (eap != NULL && eap->read_edit);
225 int check_readonly;
226 int filtering = (flags & READ_FILTER);
227 int read_stdin = (flags & READ_STDIN);
228 int read_buffer = (flags & READ_BUFFER);
229 linenr_T read_buf_lnum = 1; /* next line to read from curbuf */
230 colnr_T read_buf_col = 0; /* next char to read from this line */
231 char_u c;
232 linenr_T lnum = from;
233 char_u *ptr = NULL; /* pointer into read buffer */
234 char_u *buffer = NULL; /* read buffer */
235 char_u *new_buffer = NULL; /* init to shut up gcc */
236 char_u *line_start = NULL; /* init to shut up gcc */
237 int wasempty; /* buffer was empty before reading */
238 colnr_T len;
239 long size = 0;
240 char_u *p;
241 long filesize = 0;
242 int skip_read = FALSE;
243 #ifdef FEAT_CRYPT
244 char_u *cryptkey = NULL;
245 #endif
246 int split = 0; /* number of split lines */
247 #define UNKNOWN 0x0fffffff /* file size is unknown */
248 linenr_T linecnt;
249 int error = FALSE; /* errors encountered */
250 int ff_error = EOL_UNKNOWN; /* file format with errors */
251 long linerest = 0; /* remaining chars in line */
252 #ifdef UNIX
253 int perm = 0;
254 int swap_mode = -1; /* protection bits for swap file */
255 #else
256 int perm;
257 #endif
258 int fileformat = 0; /* end-of-line format */
259 int keep_fileformat = FALSE;
260 struct stat st;
261 int file_readonly;
262 linenr_T skip_count = 0;
263 linenr_T read_count = 0;
264 int msg_save = msg_scroll;
265 linenr_T read_no_eol_lnum = 0; /* non-zero lnum when last line of
266 * last read was missing the eol */
267 int try_mac = (vim_strchr(p_ffs, 'm') != NULL);
268 int try_dos = (vim_strchr(p_ffs, 'd') != NULL);
269 int try_unix = (vim_strchr(p_ffs, 'x') != NULL);
270 int file_rewind = FALSE;
271 #ifdef FEAT_MBYTE
272 int can_retry;
273 linenr_T conv_error = 0; /* line nr with conversion error */
274 linenr_T illegal_byte = 0; /* line nr with illegal byte */
275 int keep_dest_enc = FALSE; /* don't retry when char doesn't fit
276 in destination encoding */
277 int bad_char_behavior = BAD_REPLACE;
278 /* BAD_KEEP, BAD_DROP or character to
279 * replace with */
280 char_u *tmpname = NULL; /* name of 'charconvert' output file */
281 int fio_flags = 0;
282 char_u *fenc; /* fileencoding to use */
283 int fenc_alloced; /* fenc_next is in allocated memory */
284 char_u *fenc_next = NULL; /* next item in 'fencs' or NULL */
285 int advance_fenc = FALSE;
286 long real_size = 0;
287 # ifdef USE_ICONV
288 iconv_t iconv_fd = (iconv_t)-1; /* descriptor for iconv() or -1 */
289 # ifdef FEAT_EVAL
290 int did_iconv = FALSE; /* TRUE when iconv() failed and trying
291 'charconvert' next */
292 # endif
293 # endif
294 int converted = FALSE; /* TRUE if conversion done */
295 int notconverted = FALSE; /* TRUE if conversion wanted but it
296 wasn't possible */
297 char_u conv_rest[CONV_RESTLEN];
298 int conv_restlen = 0; /* nr of bytes in conv_rest[] */
299 #endif
301 write_no_eol_lnum = 0; /* in case it was set by the previous read */
304 * If there is no file name yet, use the one for the read file.
305 * BF_NOTEDITED is set to reflect this.
306 * Don't do this for a read from a filter.
307 * Only do this when 'cpoptions' contains the 'f' flag.
309 if (curbuf->b_ffname == NULL
310 && !filtering
311 && fname != NULL
312 && vim_strchr(p_cpo, CPO_FNAMER) != NULL
313 && !(flags & READ_DUMMY))
315 if (set_rw_fname(fname, sfname) == FAIL)
316 return FAIL;
319 /* After reading a file the cursor line changes but we don't want to
320 * display the line. */
321 ex_no_reprint = TRUE;
323 /* don't display the file info for another buffer now */
324 need_fileinfo = FALSE;
327 * For Unix: Use the short file name whenever possible.
328 * Avoids problems with networks and when directory names are changed.
329 * Don't do this for MS-DOS, a "cd" in a sub-shell may have moved us to
330 * another directory, which we don't detect.
332 if (sfname == NULL)
333 sfname = fname;
334 #if defined(UNIX) || defined(__EMX__)
335 fname = sfname;
336 #endif
338 #ifdef FEAT_AUTOCMD
340 * The BufReadCmd and FileReadCmd events intercept the reading process by
341 * executing the associated commands instead.
343 if (!filtering && !read_stdin && !read_buffer)
345 pos_T pos;
347 pos = curbuf->b_op_start;
349 /* Set '[ mark to the line above where the lines go (line 1 if zero). */
350 curbuf->b_op_start.lnum = ((from == 0) ? 1 : from);
351 curbuf->b_op_start.col = 0;
353 if (newfile)
355 if (apply_autocmds_exarg(EVENT_BUFREADCMD, NULL, sfname,
356 FALSE, curbuf, eap))
357 #ifdef FEAT_EVAL
358 return aborting() ? FAIL : OK;
359 #else
360 return OK;
361 #endif
363 else if (apply_autocmds_exarg(EVENT_FILEREADCMD, sfname, sfname,
364 FALSE, NULL, eap))
365 #ifdef FEAT_EVAL
366 return aborting() ? FAIL : OK;
367 #else
368 return OK;
369 #endif
371 curbuf->b_op_start = pos;
373 #endif
375 if ((shortmess(SHM_OVER) || curbuf->b_help) && p_verbose == 0)
376 msg_scroll = FALSE; /* overwrite previous file message */
377 else
378 msg_scroll = TRUE; /* don't overwrite previous file message */
381 * If the name ends in a path separator, we can't open it. Check here,
382 * because reading the file may actually work, but then creating the swap
383 * file may destroy it! Reported on MS-DOS and Win 95.
384 * If the name is too long we might crash further on, quit here.
386 if (fname != NULL && *fname != NUL)
388 p = fname + STRLEN(fname);
389 if (after_pathsep(fname, p) || STRLEN(fname) >= MAXPATHL)
391 filemess(curbuf, fname, (char_u *)_("Illegal file name"), 0);
392 msg_end();
393 msg_scroll = msg_save;
394 return FAIL;
398 #ifdef UNIX
400 * On Unix it is possible to read a directory, so we have to
401 * check for it before the mch_open().
403 if (!read_stdin && !read_buffer)
405 perm = mch_getperm(fname);
406 if (perm >= 0 && !S_ISREG(perm) /* not a regular file ... */
407 # ifdef S_ISFIFO
408 && !S_ISFIFO(perm) /* ... or fifo */
409 # endif
410 # ifdef S_ISSOCK
411 && !S_ISSOCK(perm) /* ... or socket */
412 # endif
413 # ifdef OPEN_CHR_FILES
414 && !(S_ISCHR(perm) && is_dev_fd_file(fname))
415 /* ... or a character special file named /dev/fd/<n> */
416 # endif
419 if (S_ISDIR(perm))
420 filemess(curbuf, fname, (char_u *)_("is a directory"), 0);
421 else
422 filemess(curbuf, fname, (char_u *)_("is not a file"), 0);
423 msg_end();
424 msg_scroll = msg_save;
425 return FAIL;
428 # if defined(MSDOS) || defined(MSWIN) || defined(OS2)
430 * MS-Windows allows opening a device, but we will probably get stuck
431 * trying to read it.
433 if (!p_odev && mch_nodetype(fname) == NODE_WRITABLE)
435 filemess(curbuf, fname, (char_u *)_("is a device (disabled with 'opendevice' option)"), 0);
436 msg_end();
437 msg_scroll = msg_save;
438 return FAIL;
440 # endif
442 #endif
444 /* set default 'fileformat' */
445 if (set_options)
447 if (eap != NULL && eap->force_ff != 0)
448 set_fileformat(get_fileformat_force(curbuf, eap), OPT_LOCAL);
449 else if (*p_ffs != NUL)
450 set_fileformat(default_fileformat(), OPT_LOCAL);
453 /* set or reset 'binary' */
454 if (eap != NULL && eap->force_bin != 0)
456 int oldval = curbuf->b_p_bin;
458 curbuf->b_p_bin = (eap->force_bin == FORCE_BIN);
459 set_options_bin(oldval, curbuf->b_p_bin, OPT_LOCAL);
463 * When opening a new file we take the readonly flag from the file.
464 * Default is r/w, can be set to r/o below.
465 * Don't reset it when in readonly mode
466 * Only set/reset b_p_ro when BF_CHECK_RO is set.
468 check_readonly = (newfile && (curbuf->b_flags & BF_CHECK_RO));
469 if (check_readonly && !readonlymode)
470 curbuf->b_p_ro = FALSE;
472 if (newfile && !read_stdin && !read_buffer)
474 /* Remember time of file.
475 * For RISCOS, also remember the filetype.
477 if (mch_stat((char *)fname, &st) >= 0)
479 buf_store_time(curbuf, &st, fname);
480 curbuf->b_mtime_read = curbuf->b_mtime;
482 #if defined(RISCOS) && defined(FEAT_OSFILETYPE)
483 /* Read the filetype into the buffer local filetype option. */
484 mch_read_filetype(fname);
485 #endif
486 #ifdef UNIX
488 * Use the protection bits of the original file for the swap file.
489 * This makes it possible for others to read the name of the
490 * edited file from the swapfile, but only if they can read the
491 * edited file.
492 * Remove the "write" and "execute" bits for group and others
493 * (they must not write the swapfile).
494 * Add the "read" and "write" bits for the user, otherwise we may
495 * not be able to write to the file ourselves.
496 * Setting the bits is done below, after creating the swap file.
498 swap_mode = (st.st_mode & 0644) | 0600;
499 #endif
500 #ifdef FEAT_CW_EDITOR
501 /* Get the FSSpec on MacOS
502 * TODO: Update it properly when the buffer name changes
504 (void)GetFSSpecFromPath(curbuf->b_ffname, &curbuf->b_FSSpec);
505 #endif
506 #ifdef VMS
507 curbuf->b_fab_rfm = st.st_fab_rfm;
508 curbuf->b_fab_rat = st.st_fab_rat;
509 curbuf->b_fab_mrs = st.st_fab_mrs;
510 #endif
512 else
514 curbuf->b_mtime = 0;
515 curbuf->b_mtime_read = 0;
516 curbuf->b_orig_size = 0;
517 curbuf->b_orig_mode = 0;
520 /* Reset the "new file" flag. It will be set again below when the
521 * file doesn't exist. */
522 curbuf->b_flags &= ~(BF_NEW | BF_NEW_W);
526 * for UNIX: check readonly with perm and mch_access()
527 * for RISCOS: same as Unix, otherwise file gets re-datestamped!
528 * for MSDOS and Amiga: check readonly by trying to open the file for writing
530 file_readonly = FALSE;
531 if (read_stdin)
533 #if defined(MSDOS) || defined(MSWIN) || defined(OS2)
534 /* Force binary I/O on stdin to avoid CR-LF -> LF conversion. */
535 setmode(0, O_BINARY);
536 #endif
538 else if (!read_buffer)
540 #ifdef USE_MCH_ACCESS
541 if (
542 # ifdef UNIX
543 !(perm & 0222) ||
544 # endif
545 mch_access((char *)fname, W_OK))
546 file_readonly = TRUE;
547 fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
548 #else
549 if (!newfile
550 || readonlymode
551 || (fd = mch_open((char *)fname, O_RDWR | O_EXTRA, 0)) < 0)
553 file_readonly = TRUE;
554 /* try to open ro */
555 fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
557 #endif
560 if (fd < 0) /* cannot open at all */
562 #ifndef UNIX
563 int isdir_f;
564 #endif
565 msg_scroll = msg_save;
566 #ifndef UNIX
568 * On MSDOS and Amiga we can't open a directory, check here.
570 isdir_f = (mch_isdir(fname));
571 perm = mch_getperm(fname); /* check if the file exists */
572 if (isdir_f)
574 filemess(curbuf, sfname, (char_u *)_("is a directory"), 0);
575 curbuf->b_p_ro = TRUE; /* must use "w!" now */
577 else
578 #endif
579 if (newfile)
581 if (perm < 0)
584 * Set the 'new-file' flag, so that when the file has
585 * been created by someone else, a ":w" will complain.
587 curbuf->b_flags |= BF_NEW;
589 /* Create a swap file now, so that other Vims are warned
590 * that we are editing this file. Don't do this for a
591 * "nofile" or "nowrite" buffer type. */
592 #ifdef FEAT_QUICKFIX
593 if (!bt_dontwrite(curbuf))
594 #endif
595 check_need_swap(newfile);
596 if (dir_of_file_exists(fname))
597 filemess(curbuf, sfname, (char_u *)_("[New File]"), 0);
598 else
599 filemess(curbuf, sfname,
600 (char_u *)_("[New DIRECTORY]"), 0);
601 #ifdef FEAT_VIMINFO
602 /* Even though this is a new file, it might have been
603 * edited before and deleted. Get the old marks. */
604 check_marks_read();
605 #endif
606 #ifdef FEAT_MBYTE
607 if (eap != NULL && eap->force_enc != 0)
609 /* set forced 'fileencoding' */
610 fenc = enc_canonize(eap->cmd + eap->force_enc);
611 if (fenc != NULL)
612 set_string_option_direct((char_u *)"fenc", -1,
613 fenc, OPT_FREE|OPT_LOCAL, 0);
614 vim_free(fenc);
616 #endif
617 #ifdef FEAT_AUTOCMD
618 apply_autocmds_exarg(EVENT_BUFNEWFILE, sfname, sfname,
619 FALSE, curbuf, eap);
620 #endif
621 /* remember the current fileformat */
622 save_file_ff(curbuf);
624 #if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
625 if (aborting()) /* autocmds may abort script processing */
626 return FAIL;
627 #endif
628 return OK; /* a new file is not an error */
630 else
632 filemess(curbuf, sfname, (char_u *)(
633 # ifdef EFBIG
634 (errno == EFBIG) ? _("[File too big]") :
635 # endif
636 _("[Permission Denied]")), 0);
637 curbuf->b_p_ro = TRUE; /* must use "w!" now */
641 return FAIL;
645 * Only set the 'ro' flag for readonly files the first time they are
646 * loaded. Help files always get readonly mode
648 if ((check_readonly && file_readonly) || curbuf->b_help)
649 curbuf->b_p_ro = TRUE;
651 if (set_options)
653 curbuf->b_p_eol = TRUE;
654 curbuf->b_start_eol = TRUE;
655 #ifdef FEAT_MBYTE
656 curbuf->b_p_bomb = FALSE;
657 curbuf->b_start_bomb = FALSE;
658 #endif
661 /* Create a swap file now, so that other Vims are warned that we are
662 * editing this file.
663 * Don't do this for a "nofile" or "nowrite" buffer type. */
664 #ifdef FEAT_QUICKFIX
665 if (!bt_dontwrite(curbuf))
666 #endif
668 check_need_swap(newfile);
669 #ifdef UNIX
670 /* Set swap file protection bits after creating it. */
671 if (swap_mode > 0 && curbuf->b_ml.ml_mfp->mf_fname != NULL)
672 (void)mch_setperm(curbuf->b_ml.ml_mfp->mf_fname, (long)swap_mode);
673 #endif
676 #if defined(HAS_SWAP_EXISTS_ACTION)
677 /* If "Quit" selected at ATTENTION dialog, don't load the file */
678 if (swap_exists_action == SEA_QUIT)
680 if (!read_buffer && !read_stdin)
681 close(fd);
682 return FAIL;
684 #endif
686 ++no_wait_return; /* don't wait for return yet */
689 * Set '[ mark to the line above where the lines go (line 1 if zero).
691 curbuf->b_op_start.lnum = ((from == 0) ? 1 : from);
692 curbuf->b_op_start.col = 0;
694 #ifdef FEAT_AUTOCMD
695 if (!read_buffer)
697 int m = msg_scroll;
698 int n = msg_scrolled;
699 buf_T *old_curbuf = curbuf;
702 * The file must be closed again, the autocommands may want to change
703 * the file before reading it.
705 if (!read_stdin)
706 close(fd); /* ignore errors */
709 * The output from the autocommands should not overwrite anything and
710 * should not be overwritten: Set msg_scroll, restore its value if no
711 * output was done.
713 msg_scroll = TRUE;
714 if (filtering)
715 apply_autocmds_exarg(EVENT_FILTERREADPRE, NULL, sfname,
716 FALSE, curbuf, eap);
717 else if (read_stdin)
718 apply_autocmds_exarg(EVENT_STDINREADPRE, NULL, sfname,
719 FALSE, curbuf, eap);
720 else if (newfile)
721 apply_autocmds_exarg(EVENT_BUFREADPRE, NULL, sfname,
722 FALSE, curbuf, eap);
723 else
724 apply_autocmds_exarg(EVENT_FILEREADPRE, sfname, sfname,
725 FALSE, NULL, eap);
726 if (msg_scrolled == n)
727 msg_scroll = m;
729 #ifdef FEAT_EVAL
730 if (aborting()) /* autocmds may abort script processing */
732 --no_wait_return;
733 msg_scroll = msg_save;
734 curbuf->b_p_ro = TRUE; /* must use "w!" now */
735 return FAIL;
737 #endif
739 * Don't allow the autocommands to change the current buffer.
740 * Try to re-open the file.
742 if (!read_stdin && (curbuf != old_curbuf
743 || (fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0)) < 0))
745 --no_wait_return;
746 msg_scroll = msg_save;
747 if (fd < 0)
748 EMSG(_("E200: *ReadPre autocommands made the file unreadable"));
749 else
750 EMSG(_("E201: *ReadPre autocommands must not change current buffer"));
751 curbuf->b_p_ro = TRUE; /* must use "w!" now */
752 return FAIL;
755 #endif /* FEAT_AUTOCMD */
757 /* Autocommands may add lines to the file, need to check if it is empty */
758 wasempty = (curbuf->b_ml.ml_flags & ML_EMPTY);
760 if (!recoverymode && !filtering && !(flags & READ_DUMMY))
763 * Show the user that we are busy reading the input. Sometimes this
764 * may take a while. When reading from stdin another program may
765 * still be running, don't move the cursor to the last line, unless
766 * always using the GUI.
768 if (read_stdin)
770 #ifndef ALWAYS_USE_GUI
771 mch_msg(_("Vim: Reading from stdin...\n"));
772 #endif
773 #ifdef FEAT_GUI
774 /* Also write a message in the GUI window, if there is one. */
775 if (gui.in_use && !gui.dying && !gui.starting)
777 p = (char_u *)_("Reading from stdin...");
778 gui_write(p, (int)STRLEN(p));
780 #endif
782 else if (!read_buffer)
783 filemess(curbuf, sfname, (char_u *)"", 0);
786 msg_scroll = FALSE; /* overwrite the file message */
789 * Set linecnt now, before the "retry" caused by a wrong guess for
790 * fileformat, and after the autocommands, which may change them.
792 linecnt = curbuf->b_ml.ml_line_count;
794 #ifdef FEAT_MBYTE
795 /* "++bad=" argument. */
796 if (eap != NULL && eap->bad_char != 0)
798 bad_char_behavior = eap->bad_char;
799 if (set_options)
800 curbuf->b_bad_char = eap->bad_char;
802 else
803 curbuf->b_bad_char = 0;
806 * Decide which 'encoding' to use or use first.
808 if (eap != NULL && eap->force_enc != 0)
810 fenc = enc_canonize(eap->cmd + eap->force_enc);
811 fenc_alloced = TRUE;
812 keep_dest_enc = TRUE;
814 else if (curbuf->b_p_bin)
816 fenc = (char_u *)""; /* binary: don't convert */
817 fenc_alloced = FALSE;
819 else if (curbuf->b_help)
821 char_u firstline[80];
822 int fc;
824 /* Help files are either utf-8 or latin1. Try utf-8 first, if this
825 * fails it must be latin1.
826 * Always do this when 'encoding' is "utf-8". Otherwise only do
827 * this when needed to avoid [converted] remarks all the time.
828 * It is needed when the first line contains non-ASCII characters.
829 * That is only in *.??x files. */
830 fenc = (char_u *)"latin1";
831 c = enc_utf8;
832 if (!c && !read_stdin)
834 fc = fname[STRLEN(fname) - 1];
835 if (TOLOWER_ASC(fc) == 'x')
837 /* Read the first line (and a bit more). Immediately rewind to
838 * the start of the file. If the read() fails "len" is -1. */
839 len = vim_read(fd, firstline, 80);
840 lseek(fd, (off_t)0L, SEEK_SET);
841 for (p = firstline; p < firstline + len; ++p)
842 if (*p >= 0x80)
844 c = TRUE;
845 break;
850 if (c)
852 fenc_next = fenc;
853 fenc = (char_u *)"utf-8";
855 /* When the file is utf-8 but a character doesn't fit in
856 * 'encoding' don't retry. In help text editing utf-8 bytes
857 * doesn't make sense. */
858 if (!enc_utf8)
859 keep_dest_enc = TRUE;
861 fenc_alloced = FALSE;
863 else if (*p_fencs == NUL)
865 fenc = curbuf->b_p_fenc; /* use format from buffer */
866 fenc_alloced = FALSE;
868 else
870 fenc_next = p_fencs; /* try items in 'fileencodings' */
871 fenc = next_fenc(&fenc_next);
872 fenc_alloced = TRUE;
874 #endif
877 * Jump back here to retry reading the file in different ways.
878 * Reasons to retry:
879 * - encoding conversion failed: try another one from "fenc_next"
880 * - BOM detected and fenc was set, need to setup conversion
881 * - "fileformat" check failed: try another
883 * Variables set for special retry actions:
884 * "file_rewind" Rewind the file to start reading it again.
885 * "advance_fenc" Advance "fenc" using "fenc_next".
886 * "skip_read" Re-use already read bytes (BOM detected).
887 * "did_iconv" iconv() conversion failed, try 'charconvert'.
888 * "keep_fileformat" Don't reset "fileformat".
890 * Other status indicators:
891 * "tmpname" When != NULL did conversion with 'charconvert'.
892 * Output file has to be deleted afterwards.
893 * "iconv_fd" When != -1 did conversion with iconv().
895 retry:
897 if (file_rewind)
899 if (read_buffer)
901 read_buf_lnum = 1;
902 read_buf_col = 0;
904 else if (read_stdin || lseek(fd, (off_t)0L, SEEK_SET) != 0)
906 /* Can't rewind the file, give up. */
907 error = TRUE;
908 goto failed;
910 /* Delete the previously read lines. */
911 while (lnum > from)
912 ml_delete(lnum--, FALSE);
913 file_rewind = FALSE;
914 #ifdef FEAT_MBYTE
915 if (set_options)
917 curbuf->b_p_bomb = FALSE;
918 curbuf->b_start_bomb = FALSE;
920 conv_error = 0;
921 #endif
925 * When retrying with another "fenc" and the first time "fileformat"
926 * will be reset.
928 if (keep_fileformat)
929 keep_fileformat = FALSE;
930 else
932 if (eap != NULL && eap->force_ff != 0)
933 fileformat = get_fileformat_force(curbuf, eap);
934 else if (curbuf->b_p_bin)
935 fileformat = EOL_UNIX; /* binary: use Unix format */
936 else if (*p_ffs == NUL)
937 fileformat = get_fileformat(curbuf);/* use format from buffer */
938 else
939 fileformat = EOL_UNKNOWN; /* detect from file */
942 #ifdef FEAT_MBYTE
943 # ifdef USE_ICONV
944 if (iconv_fd != (iconv_t)-1)
946 /* aborted conversion with iconv(), close the descriptor */
947 iconv_close(iconv_fd);
948 iconv_fd = (iconv_t)-1;
950 # endif
952 if (advance_fenc)
955 * Try the next entry in 'fileencodings'.
957 advance_fenc = FALSE;
959 if (eap != NULL && eap->force_enc != 0)
961 /* Conversion given with "++cc=" wasn't possible, read
962 * without conversion. */
963 notconverted = TRUE;
964 conv_error = 0;
965 if (fenc_alloced)
966 vim_free(fenc);
967 fenc = (char_u *)"";
968 fenc_alloced = FALSE;
970 else
972 if (fenc_alloced)
973 vim_free(fenc);
974 if (fenc_next != NULL)
976 fenc = next_fenc(&fenc_next);
977 fenc_alloced = (fenc_next != NULL);
979 else
981 fenc = (char_u *)"";
982 fenc_alloced = FALSE;
985 if (tmpname != NULL)
987 mch_remove(tmpname); /* delete converted file */
988 vim_free(tmpname);
989 tmpname = NULL;
994 * Conversion is required when the encoding of the file is different
995 * from 'encoding' or 'encoding' is UTF-16, UCS-2 or UCS-4 (requires
996 * conversion to UTF-8).
998 fio_flags = 0;
999 converted = (*fenc != NUL && !same_encoding(p_enc, fenc));
1000 if (converted || enc_unicode != 0)
1003 /* "ucs-bom" means we need to check the first bytes of the file
1004 * for a BOM. */
1005 if (STRCMP(fenc, ENC_UCSBOM) == 0)
1006 fio_flags = FIO_UCSBOM;
1009 * Check if UCS-2/4 or Latin1 to UTF-8 conversion needs to be
1010 * done. This is handled below after read(). Prepare the
1011 * fio_flags to avoid having to parse the string each time.
1012 * Also check for Unicode to Latin1 conversion, because iconv()
1013 * appears not to handle this correctly. This works just like
1014 * conversion to UTF-8 except how the resulting character is put in
1015 * the buffer.
1017 else if (enc_utf8 || STRCMP(p_enc, "latin1") == 0)
1018 fio_flags = get_fio_flags(fenc);
1020 # ifdef WIN3264
1022 * Conversion from an MS-Windows codepage to UTF-8 or another codepage
1023 * is handled with MultiByteToWideChar().
1025 if (fio_flags == 0)
1026 fio_flags = get_win_fio_flags(fenc);
1027 # endif
1029 # ifdef MACOS_X
1030 /* Conversion from Apple MacRoman to latin1 or UTF-8 */
1031 if (fio_flags == 0)
1032 fio_flags = get_mac_fio_flags(fenc);
1033 # endif
1035 # ifdef USE_ICONV
1037 * Try using iconv() if we can't convert internally.
1039 if (fio_flags == 0
1040 # ifdef FEAT_EVAL
1041 && !did_iconv
1042 # endif
1044 iconv_fd = (iconv_t)my_iconv_open(
1045 enc_utf8 ? (char_u *)"utf-8" : p_enc, fenc);
1046 # endif
1048 # ifdef FEAT_EVAL
1050 * Use the 'charconvert' expression when conversion is required
1051 * and we can't do it internally or with iconv().
1053 if (fio_flags == 0 && !read_stdin && !read_buffer && *p_ccv != NUL
1054 # ifdef USE_ICONV
1055 && iconv_fd == (iconv_t)-1
1056 # endif
1059 # ifdef USE_ICONV
1060 did_iconv = FALSE;
1061 # endif
1062 /* Skip conversion when it's already done (retry for wrong
1063 * "fileformat"). */
1064 if (tmpname == NULL)
1066 tmpname = readfile_charconvert(fname, fenc, &fd);
1067 if (tmpname == NULL)
1069 /* Conversion failed. Try another one. */
1070 advance_fenc = TRUE;
1071 if (fd < 0)
1073 /* Re-opening the original file failed! */
1074 EMSG(_("E202: Conversion made file unreadable!"));
1075 error = TRUE;
1076 goto failed;
1078 goto retry;
1082 else
1083 # endif
1085 if (fio_flags == 0
1086 # ifdef USE_ICONV
1087 && iconv_fd == (iconv_t)-1
1088 # endif
1091 /* Conversion wanted but we can't.
1092 * Try the next conversion in 'fileencodings' */
1093 advance_fenc = TRUE;
1094 goto retry;
1099 /* Set "can_retry" when it's possible to rewind the file and try with
1100 * another "fenc" value. It's FALSE when no other "fenc" to try, reading
1101 * stdin or fixed at a specific encoding. */
1102 can_retry = (*fenc != NUL && !read_stdin && !keep_dest_enc);
1103 #endif
1105 if (!skip_read)
1107 linerest = 0;
1108 filesize = 0;
1109 skip_count = lines_to_skip;
1110 read_count = lines_to_read;
1111 #ifdef FEAT_MBYTE
1112 conv_restlen = 0;
1113 #endif
1116 while (!error && !got_int)
1119 * We allocate as much space for the file as we can get, plus
1120 * space for the old line plus room for one terminating NUL.
1121 * The amount is limited by the fact that read() only can read
1122 * upto max_unsigned characters (and other things).
1124 #if SIZEOF_INT <= 2
1125 if (linerest >= 0x7ff0)
1127 ++split;
1128 *ptr = NL; /* split line by inserting a NL */
1129 size = 1;
1131 else
1132 #endif
1134 if (!skip_read)
1136 #if SIZEOF_INT > 2
1137 # if defined(SSIZE_MAX) && (SSIZE_MAX < 0x10000L)
1138 size = SSIZE_MAX; /* use max I/O size, 52K */
1139 # else
1140 size = 0x10000L; /* use buffer >= 64K */
1141 # endif
1142 #else
1143 size = 0x7ff0L - linerest; /* limit buffer to 32K */
1144 #endif
1146 for ( ; size >= 10; size = (long)((long_u)size >> 1))
1148 if ((new_buffer = lalloc((long_u)(size + linerest + 1),
1149 FALSE)) != NULL)
1150 break;
1152 if (new_buffer == NULL)
1154 do_outofmem_msg((long_u)(size * 2 + linerest + 1));
1155 error = TRUE;
1156 break;
1158 if (linerest) /* copy characters from the previous buffer */
1159 mch_memmove(new_buffer, ptr - linerest, (size_t)linerest);
1160 vim_free(buffer);
1161 buffer = new_buffer;
1162 ptr = buffer + linerest;
1163 line_start = buffer;
1165 #ifdef FEAT_MBYTE
1166 /* May need room to translate into.
1167 * For iconv() we don't really know the required space, use a
1168 * factor ICONV_MULT.
1169 * latin1 to utf-8: 1 byte becomes up to 2 bytes
1170 * utf-16 to utf-8: 2 bytes become up to 3 bytes, 4 bytes
1171 * become up to 4 bytes, size must be multiple of 2
1172 * ucs-2 to utf-8: 2 bytes become up to 3 bytes, size must be
1173 * multiple of 2
1174 * ucs-4 to utf-8: 4 bytes become up to 6 bytes, size must be
1175 * multiple of 4 */
1176 real_size = (int)size;
1177 # ifdef USE_ICONV
1178 if (iconv_fd != (iconv_t)-1)
1179 size = size / ICONV_MULT;
1180 else
1181 # endif
1182 if (fio_flags & FIO_LATIN1)
1183 size = size / 2;
1184 else if (fio_flags & (FIO_UCS2 | FIO_UTF16))
1185 size = (size * 2 / 3) & ~1;
1186 else if (fio_flags & FIO_UCS4)
1187 size = (size * 2 / 3) & ~3;
1188 else if (fio_flags == FIO_UCSBOM)
1189 size = size / ICONV_MULT; /* worst case */
1190 # ifdef WIN3264
1191 else if (fio_flags & FIO_CODEPAGE)
1192 size = size / ICONV_MULT; /* also worst case */
1193 # endif
1194 # ifdef MACOS_X
1195 else if (fio_flags & FIO_MACROMAN)
1196 size = size / ICONV_MULT; /* also worst case */
1197 # endif
1198 #endif
1200 #ifdef FEAT_MBYTE
1201 if (conv_restlen > 0)
1203 /* Insert unconverted bytes from previous line. */
1204 mch_memmove(ptr, conv_rest, conv_restlen);
1205 ptr += conv_restlen;
1206 size -= conv_restlen;
1208 #endif
1210 if (read_buffer)
1213 * Read bytes from curbuf. Used for converting text read
1214 * from stdin.
1216 if (read_buf_lnum > from)
1217 size = 0;
1218 else
1220 int n, ni;
1221 long tlen;
1223 tlen = 0;
1224 for (;;)
1226 p = ml_get(read_buf_lnum) + read_buf_col;
1227 n = (int)STRLEN(p);
1228 if ((int)tlen + n + 1 > size)
1230 /* Filled up to "size", append partial line.
1231 * Change NL to NUL to reverse the effect done
1232 * below. */
1233 n = (int)(size - tlen);
1234 for (ni = 0; ni < n; ++ni)
1236 if (p[ni] == NL)
1237 ptr[tlen++] = NUL;
1238 else
1239 ptr[tlen++] = p[ni];
1241 read_buf_col += n;
1242 break;
1244 else
1246 /* Append whole line and new-line. Change NL
1247 * to NUL to reverse the effect done below. */
1248 for (ni = 0; ni < n; ++ni)
1250 if (p[ni] == NL)
1251 ptr[tlen++] = NUL;
1252 else
1253 ptr[tlen++] = p[ni];
1255 ptr[tlen++] = NL;
1256 read_buf_col = 0;
1257 if (++read_buf_lnum > from)
1259 /* When the last line didn't have an
1260 * end-of-line don't add it now either. */
1261 if (!curbuf->b_p_eol)
1262 --tlen;
1263 size = tlen;
1264 break;
1270 else
1273 * Read bytes from the file.
1275 size = vim_read(fd, ptr, size);
1278 if (size <= 0)
1280 if (size < 0) /* read error */
1281 error = TRUE;
1282 #ifdef FEAT_MBYTE
1283 else if (conv_restlen > 0)
1285 /* Reached end-of-file but some trailing bytes could
1286 * not be converted. Truncated file? */
1287 if (conv_error == 0)
1288 conv_error = linecnt;
1289 if (bad_char_behavior != BAD_DROP)
1291 fio_flags = 0; /* don't convert this */
1292 # ifdef USE_ICONV
1293 if (iconv_fd != (iconv_t)-1)
1295 iconv_close(iconv_fd);
1296 iconv_fd = (iconv_t)-1;
1298 # endif
1299 if (bad_char_behavior == BAD_KEEP)
1301 /* Keep the trailing bytes as-is. */
1302 size = conv_restlen;
1303 ptr -= conv_restlen;
1305 else
1307 /* Replace the trailing bytes with the
1308 * replacement character. */
1309 size = 1;
1310 *--ptr = bad_char_behavior;
1312 conv_restlen = 0;
1315 #endif
1318 #ifdef FEAT_CRYPT
1320 * At start of file: Check for magic number of encryption.
1322 if (filesize == 0)
1323 cryptkey = check_for_cryptkey(cryptkey, ptr, &size,
1324 &filesize, newfile);
1326 * Decrypt the read bytes.
1328 if (cryptkey != NULL && size > 0)
1329 for (p = ptr; p < ptr + size; ++p)
1330 ZDECODE(*p);
1331 #endif
1333 skip_read = FALSE;
1335 #ifdef FEAT_MBYTE
1337 * At start of file (or after crypt magic number): Check for BOM.
1338 * Also check for a BOM for other Unicode encodings, but not after
1339 * converting with 'charconvert' or when a BOM has already been
1340 * found.
1342 if ((filesize == 0
1343 # ifdef FEAT_CRYPT
1344 || (filesize == CRYPT_MAGIC_LEN && cryptkey != NULL)
1345 # endif
1347 && (fio_flags == FIO_UCSBOM
1348 || (!curbuf->b_p_bomb
1349 && tmpname == NULL
1350 && (*fenc == 'u' || (*fenc == NUL && enc_utf8)))))
1352 char_u *ccname;
1353 int blen;
1355 /* no BOM detection in a short file or in binary mode */
1356 if (size < 2 || curbuf->b_p_bin)
1357 ccname = NULL;
1358 else
1359 ccname = check_for_bom(ptr, size, &blen,
1360 fio_flags == FIO_UCSBOM ? FIO_ALL : get_fio_flags(fenc));
1361 if (ccname != NULL)
1363 /* Remove BOM from the text */
1364 filesize += blen;
1365 size -= blen;
1366 mch_memmove(ptr, ptr + blen, (size_t)size);
1367 if (set_options)
1369 curbuf->b_p_bomb = TRUE;
1370 curbuf->b_start_bomb = TRUE;
1374 if (fio_flags == FIO_UCSBOM)
1376 if (ccname == NULL)
1378 /* No BOM detected: retry with next encoding. */
1379 advance_fenc = TRUE;
1381 else
1383 /* BOM detected: set "fenc" and jump back */
1384 if (fenc_alloced)
1385 vim_free(fenc);
1386 fenc = ccname;
1387 fenc_alloced = FALSE;
1389 /* retry reading without getting new bytes or rewinding */
1390 skip_read = TRUE;
1391 goto retry;
1394 #endif
1396 * Break here for a read error or end-of-file.
1398 if (size <= 0)
1399 break;
1401 #ifdef FEAT_MBYTE
1403 /* Include not converted bytes. */
1404 ptr -= conv_restlen;
1405 size += conv_restlen;
1406 conv_restlen = 0;
1408 # ifdef USE_ICONV
1409 if (iconv_fd != (iconv_t)-1)
1412 * Attempt conversion of the read bytes to 'encoding' using
1413 * iconv().
1415 const char *fromp;
1416 char *top;
1417 size_t from_size;
1418 size_t to_size;
1420 fromp = (char *)ptr;
1421 from_size = size;
1422 ptr += size;
1423 top = (char *)ptr;
1424 to_size = real_size - size;
1427 * If there is conversion error or not enough room try using
1428 * another conversion. Except for when there is no
1429 * alternative (help files).
1431 while ((iconv(iconv_fd, (void *)&fromp, &from_size,
1432 &top, &to_size)
1433 == (size_t)-1 && ICONV_ERRNO != ICONV_EINVAL)
1434 || from_size > CONV_RESTLEN)
1436 if (can_retry)
1437 goto rewind_retry;
1438 if (conv_error == 0)
1439 conv_error = readfile_linenr(linecnt,
1440 ptr, (char_u *)top);
1442 /* Deal with a bad byte and continue with the next. */
1443 ++fromp;
1444 --from_size;
1445 if (bad_char_behavior == BAD_KEEP)
1447 *top++ = *(fromp - 1);
1448 --to_size;
1450 else if (bad_char_behavior != BAD_DROP)
1452 *top++ = bad_char_behavior;
1453 --to_size;
1457 if (from_size > 0)
1459 /* Some remaining characters, keep them for the next
1460 * round. */
1461 mch_memmove(conv_rest, (char_u *)fromp, from_size);
1462 conv_restlen = (int)from_size;
1465 /* move the linerest to before the converted characters */
1466 line_start = ptr - linerest;
1467 mch_memmove(line_start, buffer, (size_t)linerest);
1468 size = (long)((char_u *)top - ptr);
1470 # endif
1472 # ifdef WIN3264
1473 if (fio_flags & FIO_CODEPAGE)
1475 char_u *src, *dst;
1476 WCHAR ucs2buf[3];
1477 int ucs2len;
1478 int codepage = FIO_GET_CP(fio_flags);
1479 int bytelen;
1480 int found_bad;
1481 char replstr[2];
1484 * Conversion from an MS-Windows codepage or UTF-8 to UTF-8 or
1485 * a codepage, using standard MS-Windows functions. This
1486 * requires two steps:
1487 * 1. convert from 'fileencoding' to ucs-2
1488 * 2. convert from ucs-2 to 'encoding'
1490 * Because there may be illegal bytes AND an incomplete byte
1491 * sequence at the end, we may have to do the conversion one
1492 * character at a time to get it right.
1495 /* Replacement string for WideCharToMultiByte(). */
1496 if (bad_char_behavior > 0)
1497 replstr[0] = bad_char_behavior;
1498 else
1499 replstr[0] = '?';
1500 replstr[1] = NUL;
1503 * Move the bytes to the end of the buffer, so that we have
1504 * room to put the result at the start.
1506 src = ptr + real_size - size;
1507 mch_memmove(src, ptr, size);
1510 * Do the conversion.
1512 dst = ptr;
1513 size = size;
1514 while (size > 0)
1516 found_bad = FALSE;
1518 # ifdef CP_UTF8 /* VC 4.1 doesn't define CP_UTF8 */
1519 if (codepage == CP_UTF8)
1521 /* Handle CP_UTF8 input ourselves to be able to handle
1522 * trailing bytes properly.
1523 * Get one UTF-8 character from src. */
1524 bytelen = (int)utf_ptr2len_len(src, size);
1525 if (bytelen > size)
1527 /* Only got some bytes of a character. Normally
1528 * it's put in "conv_rest", but if it's too long
1529 * deal with it as if they were illegal bytes. */
1530 if (bytelen <= CONV_RESTLEN)
1531 break;
1533 /* weird overlong byte sequence */
1534 bytelen = size;
1535 found_bad = TRUE;
1537 else
1539 int u8c = utf_ptr2char(src);
1541 if (u8c > 0xffff || (*src >= 0x80 && bytelen == 1))
1542 found_bad = TRUE;
1543 ucs2buf[0] = u8c;
1544 ucs2len = 1;
1547 else
1548 # endif
1550 /* We don't know how long the byte sequence is, try
1551 * from one to three bytes. */
1552 for (bytelen = 1; bytelen <= size && bytelen <= 3;
1553 ++bytelen)
1555 ucs2len = MultiByteToWideChar(codepage,
1556 MB_ERR_INVALID_CHARS,
1557 (LPCSTR)src, bytelen,
1558 ucs2buf, 3);
1559 if (ucs2len > 0)
1560 break;
1562 if (ucs2len == 0)
1564 /* If we have only one byte then it's probably an
1565 * incomplete byte sequence. Otherwise discard
1566 * one byte as a bad character. */
1567 if (size == 1)
1568 break;
1569 found_bad = TRUE;
1570 bytelen = 1;
1574 if (!found_bad)
1576 int i;
1578 /* Convert "ucs2buf[ucs2len]" to 'enc' in "dst". */
1579 if (enc_utf8)
1581 /* From UCS-2 to UTF-8. Cannot fail. */
1582 for (i = 0; i < ucs2len; ++i)
1583 dst += utf_char2bytes(ucs2buf[i], dst);
1585 else
1587 BOOL bad = FALSE;
1588 int dstlen;
1590 /* From UCS-2 to "enc_codepage". If the
1591 * conversion uses the default character "?",
1592 * the data doesn't fit in this encoding. */
1593 dstlen = WideCharToMultiByte(enc_codepage, 0,
1594 (LPCWSTR)ucs2buf, ucs2len,
1595 (LPSTR)dst, (int)(src - dst),
1596 replstr, &bad);
1597 if (bad)
1598 found_bad = TRUE;
1599 else
1600 dst += dstlen;
1604 if (found_bad)
1606 /* Deal with bytes we can't convert. */
1607 if (can_retry)
1608 goto rewind_retry;
1609 if (conv_error == 0)
1610 conv_error = readfile_linenr(linecnt, ptr, dst);
1611 if (bad_char_behavior != BAD_DROP)
1613 if (bad_char_behavior == BAD_KEEP)
1615 mch_memmove(dst, src, bytelen);
1616 dst += bytelen;
1618 else
1619 *dst++ = bad_char_behavior;
1623 src += bytelen;
1624 size -= bytelen;
1627 if (size > 0)
1629 /* An incomplete byte sequence remaining. */
1630 mch_memmove(conv_rest, src, size);
1631 conv_restlen = size;
1634 /* The new size is equal to how much "dst" was advanced. */
1635 size = (long)(dst - ptr);
1637 else
1638 # endif
1639 # ifdef MACOS_CONVERT
1640 if (fio_flags & FIO_MACROMAN)
1643 * Conversion from Apple MacRoman char encoding to UTF-8 or
1644 * latin1. This is in os_mac_conv.c.
1646 if (macroman2enc(ptr, &size, real_size) == FAIL)
1647 goto rewind_retry;
1649 else
1650 # endif
1651 if (fio_flags != 0)
1653 int u8c;
1654 char_u *dest;
1655 char_u *tail = NULL;
1658 * "enc_utf8" set: Convert Unicode or Latin1 to UTF-8.
1659 * "enc_utf8" not set: Convert Unicode to Latin1.
1660 * Go from end to start through the buffer, because the number
1661 * of bytes may increase.
1662 * "dest" points to after where the UTF-8 bytes go, "p" points
1663 * to after the next character to convert.
1665 dest = ptr + real_size;
1666 if (fio_flags == FIO_LATIN1 || fio_flags == FIO_UTF8)
1668 p = ptr + size;
1669 if (fio_flags == FIO_UTF8)
1671 /* Check for a trailing incomplete UTF-8 sequence */
1672 tail = ptr + size - 1;
1673 while (tail > ptr && (*tail & 0xc0) == 0x80)
1674 --tail;
1675 if (tail + utf_byte2len(*tail) <= ptr + size)
1676 tail = NULL;
1677 else
1678 p = tail;
1681 else if (fio_flags & (FIO_UCS2 | FIO_UTF16))
1683 /* Check for a trailing byte */
1684 p = ptr + (size & ~1);
1685 if (size & 1)
1686 tail = p;
1687 if ((fio_flags & FIO_UTF16) && p > ptr)
1689 /* Check for a trailing leading word */
1690 if (fio_flags & FIO_ENDIAN_L)
1692 u8c = (*--p << 8);
1693 u8c += *--p;
1695 else
1697 u8c = *--p;
1698 u8c += (*--p << 8);
1700 if (u8c >= 0xd800 && u8c <= 0xdbff)
1701 tail = p;
1702 else
1703 p += 2;
1706 else /* FIO_UCS4 */
1708 /* Check for trailing 1, 2 or 3 bytes */
1709 p = ptr + (size & ~3);
1710 if (size & 3)
1711 tail = p;
1714 /* If there is a trailing incomplete sequence move it to
1715 * conv_rest[]. */
1716 if (tail != NULL)
1718 conv_restlen = (int)((ptr + size) - tail);
1719 mch_memmove(conv_rest, (char_u *)tail, conv_restlen);
1720 size -= conv_restlen;
1724 while (p > ptr)
1726 if (fio_flags & FIO_LATIN1)
1727 u8c = *--p;
1728 else if (fio_flags & (FIO_UCS2 | FIO_UTF16))
1730 if (fio_flags & FIO_ENDIAN_L)
1732 u8c = (*--p << 8);
1733 u8c += *--p;
1735 else
1737 u8c = *--p;
1738 u8c += (*--p << 8);
1740 if ((fio_flags & FIO_UTF16)
1741 && u8c >= 0xdc00 && u8c <= 0xdfff)
1743 int u16c;
1745 if (p == ptr)
1747 /* Missing leading word. */
1748 if (can_retry)
1749 goto rewind_retry;
1750 if (conv_error == 0)
1751 conv_error = readfile_linenr(linecnt,
1752 ptr, p);
1753 if (bad_char_behavior == BAD_DROP)
1754 continue;
1755 if (bad_char_behavior != BAD_KEEP)
1756 u8c = bad_char_behavior;
1759 /* found second word of double-word, get the first
1760 * word and compute the resulting character */
1761 if (fio_flags & FIO_ENDIAN_L)
1763 u16c = (*--p << 8);
1764 u16c += *--p;
1766 else
1768 u16c = *--p;
1769 u16c += (*--p << 8);
1771 u8c = 0x10000 + ((u16c & 0x3ff) << 10)
1772 + (u8c & 0x3ff);
1774 /* Check if the word is indeed a leading word. */
1775 if (u16c < 0xd800 || u16c > 0xdbff)
1777 if (can_retry)
1778 goto rewind_retry;
1779 if (conv_error == 0)
1780 conv_error = readfile_linenr(linecnt,
1781 ptr, p);
1782 if (bad_char_behavior == BAD_DROP)
1783 continue;
1784 if (bad_char_behavior != BAD_KEEP)
1785 u8c = bad_char_behavior;
1789 else if (fio_flags & FIO_UCS4)
1791 if (fio_flags & FIO_ENDIAN_L)
1793 u8c = (*--p << 24);
1794 u8c += (*--p << 16);
1795 u8c += (*--p << 8);
1796 u8c += *--p;
1798 else /* big endian */
1800 u8c = *--p;
1801 u8c += (*--p << 8);
1802 u8c += (*--p << 16);
1803 u8c += (*--p << 24);
1806 else /* UTF-8 */
1808 if (*--p < 0x80)
1809 u8c = *p;
1810 else
1812 len = utf_head_off(ptr, p);
1813 p -= len;
1814 u8c = utf_ptr2char(p);
1815 if (len == 0)
1817 /* Not a valid UTF-8 character, retry with
1818 * another fenc when possible, otherwise just
1819 * report the error. */
1820 if (can_retry)
1821 goto rewind_retry;
1822 if (conv_error == 0)
1823 conv_error = readfile_linenr(linecnt,
1824 ptr, p);
1825 if (bad_char_behavior == BAD_DROP)
1826 continue;
1827 if (bad_char_behavior != BAD_KEEP)
1828 u8c = bad_char_behavior;
1832 if (enc_utf8) /* produce UTF-8 */
1834 dest -= utf_char2len(u8c);
1835 (void)utf_char2bytes(u8c, dest);
1837 else /* produce Latin1 */
1839 --dest;
1840 if (u8c >= 0x100)
1842 /* character doesn't fit in latin1, retry with
1843 * another fenc when possible, otherwise just
1844 * report the error. */
1845 if (can_retry)
1846 goto rewind_retry;
1847 if (conv_error == 0)
1848 conv_error = readfile_linenr(linecnt, ptr, p);
1849 if (bad_char_behavior == BAD_DROP)
1850 ++dest;
1851 else if (bad_char_behavior == BAD_KEEP)
1852 *dest = u8c;
1853 else if (eap != NULL && eap->bad_char != 0)
1854 *dest = bad_char_behavior;
1855 else
1856 *dest = 0xBF;
1858 else
1859 *dest = u8c;
1863 /* move the linerest to before the converted characters */
1864 line_start = dest - linerest;
1865 mch_memmove(line_start, buffer, (size_t)linerest);
1866 size = (long)((ptr + real_size) - dest);
1867 ptr = dest;
1869 else if (enc_utf8 && conv_error == 0 && !curbuf->b_p_bin)
1871 /* Reading UTF-8: Check if the bytes are valid UTF-8.
1872 * Need to start before "ptr" when part of the character was
1873 * read in the previous read() call. */
1874 for (p = ptr - utf_head_off(buffer, ptr); ; ++p)
1876 int todo = (int)((ptr + size) - p);
1877 int l;
1879 if (todo <= 0)
1880 break;
1881 if (*p >= 0x80)
1883 /* A length of 1 means it's an illegal byte. Accept
1884 * an incomplete character at the end though, the next
1885 * read() will get the next bytes, we'll check it
1886 * then. */
1887 l = utf_ptr2len_len(p, todo);
1888 if (l > todo)
1890 /* Incomplete byte sequence, the next read()
1891 * should get them and check the bytes. */
1892 p += todo;
1893 break;
1895 if (l == 1)
1897 /* Illegal byte. If we can try another encoding
1898 * do that. */
1899 if (can_retry)
1900 break;
1902 /* Remember the first linenr with an illegal byte */
1903 if (illegal_byte == 0)
1904 illegal_byte = readfile_linenr(linecnt, ptr, p);
1905 # ifdef USE_ICONV
1906 /* When we did a conversion report an error. */
1907 if (iconv_fd != (iconv_t)-1 && conv_error == 0)
1908 conv_error = readfile_linenr(linecnt, ptr, p);
1909 # endif
1911 /* Drop, keep or replace the bad byte. */
1912 if (bad_char_behavior == BAD_DROP)
1914 mch_memmove(p, p+1, todo - 1);
1915 --p;
1916 --size;
1918 else if (bad_char_behavior != BAD_KEEP)
1919 *p = bad_char_behavior;
1921 p += l - 1;
1924 if (p < ptr + size)
1926 /* Detected a UTF-8 error. */
1927 rewind_retry:
1928 /* Retry reading with another conversion. */
1929 # if defined(FEAT_EVAL) && defined(USE_ICONV)
1930 if (*p_ccv != NUL && iconv_fd != (iconv_t)-1)
1931 /* iconv() failed, try 'charconvert' */
1932 did_iconv = TRUE;
1933 else
1934 # endif
1935 /* use next item from 'fileencodings' */
1936 advance_fenc = TRUE;
1937 file_rewind = TRUE;
1938 goto retry;
1941 #endif
1943 /* count the number of characters (after conversion!) */
1944 filesize += size;
1947 * when reading the first part of a file: guess EOL type
1949 if (fileformat == EOL_UNKNOWN)
1951 /* First try finding a NL, for Dos and Unix */
1952 if (try_dos || try_unix)
1954 for (p = ptr; p < ptr + size; ++p)
1956 if (*p == NL)
1958 if (!try_unix
1959 || (try_dos && p > ptr && p[-1] == CAR))
1960 fileformat = EOL_DOS;
1961 else
1962 fileformat = EOL_UNIX;
1963 break;
1967 /* Don't give in to EOL_UNIX if EOL_MAC is more likely */
1968 if (fileformat == EOL_UNIX && try_mac)
1970 /* Need to reset the counters when retrying fenc. */
1971 try_mac = 1;
1972 try_unix = 1;
1973 for (; p >= ptr && *p != CAR; p--)
1975 if (p >= ptr)
1977 for (p = ptr; p < ptr + size; ++p)
1979 if (*p == NL)
1980 try_unix++;
1981 else if (*p == CAR)
1982 try_mac++;
1984 if (try_mac > try_unix)
1985 fileformat = EOL_MAC;
1990 /* No NL found: may use Mac format */
1991 if (fileformat == EOL_UNKNOWN && try_mac)
1992 fileformat = EOL_MAC;
1994 /* Still nothing found? Use first format in 'ffs' */
1995 if (fileformat == EOL_UNKNOWN)
1996 fileformat = default_fileformat();
1998 /* if editing a new file: may set p_tx and p_ff */
1999 if (set_options)
2000 set_fileformat(fileformat, OPT_LOCAL);
2005 * This loop is executed once for every character read.
2006 * Keep it fast!
2008 if (fileformat == EOL_MAC)
2010 --ptr;
2011 while (++ptr, --size >= 0)
2013 /* catch most common case first */
2014 if ((c = *ptr) != NUL && c != CAR && c != NL)
2015 continue;
2016 if (c == NUL)
2017 *ptr = NL; /* NULs are replaced by newlines! */
2018 else if (c == NL)
2019 *ptr = CAR; /* NLs are replaced by CRs! */
2020 else
2022 if (skip_count == 0)
2024 *ptr = NUL; /* end of line */
2025 len = (colnr_T) (ptr - line_start + 1);
2026 if (ml_append(lnum, line_start, len, newfile) == FAIL)
2028 error = TRUE;
2029 break;
2031 ++lnum;
2032 if (--read_count == 0)
2034 error = TRUE; /* break loop */
2035 line_start = ptr; /* nothing left to write */
2036 break;
2039 else
2040 --skip_count;
2041 line_start = ptr + 1;
2045 else
2047 --ptr;
2048 while (++ptr, --size >= 0)
2050 if ((c = *ptr) != NUL && c != NL) /* catch most common case */
2051 continue;
2052 if (c == NUL)
2053 *ptr = NL; /* NULs are replaced by newlines! */
2054 else
2056 if (skip_count == 0)
2058 *ptr = NUL; /* end of line */
2059 len = (colnr_T)(ptr - line_start + 1);
2060 if (fileformat == EOL_DOS)
2062 if (ptr[-1] == CAR) /* remove CR */
2064 ptr[-1] = NUL;
2065 --len;
2068 * Reading in Dos format, but no CR-LF found!
2069 * When 'fileformats' includes "unix", delete all
2070 * the lines read so far and start all over again.
2071 * Otherwise give an error message later.
2073 else if (ff_error != EOL_DOS)
2075 if ( try_unix
2076 && !read_stdin
2077 && (read_buffer
2078 || lseek(fd, (off_t)0L, SEEK_SET) == 0))
2080 fileformat = EOL_UNIX;
2081 if (set_options)
2082 set_fileformat(EOL_UNIX, OPT_LOCAL);
2083 file_rewind = TRUE;
2084 keep_fileformat = TRUE;
2085 goto retry;
2087 ff_error = EOL_DOS;
2090 if (ml_append(lnum, line_start, len, newfile) == FAIL)
2092 error = TRUE;
2093 break;
2095 ++lnum;
2096 if (--read_count == 0)
2098 error = TRUE; /* break loop */
2099 line_start = ptr; /* nothing left to write */
2100 break;
2103 else
2104 --skip_count;
2105 line_start = ptr + 1;
2109 linerest = (long)(ptr - line_start);
2110 ui_breakcheck();
2113 failed:
2114 /* not an error, max. number of lines reached */
2115 if (error && read_count == 0)
2116 error = FALSE;
2119 * If we get EOF in the middle of a line, note the fact and
2120 * complete the line ourselves.
2121 * In Dos format ignore a trailing CTRL-Z, unless 'binary' set.
2123 if (!error
2124 && !got_int
2125 && linerest != 0
2126 && !(!curbuf->b_p_bin
2127 && fileformat == EOL_DOS
2128 && *line_start == Ctrl_Z
2129 && ptr == line_start + 1))
2131 /* remember for when writing */
2132 if (set_options)
2133 curbuf->b_p_eol = FALSE;
2134 *ptr = NUL;
2135 if (ml_append(lnum, line_start,
2136 (colnr_T)(ptr - line_start + 1), newfile) == FAIL)
2137 error = TRUE;
2138 else
2139 read_no_eol_lnum = ++lnum;
2142 if (set_options)
2143 save_file_ff(curbuf); /* remember the current file format */
2145 #ifdef FEAT_CRYPT
2146 if (cryptkey != curbuf->b_p_key)
2147 vim_free(cryptkey);
2148 #endif
2150 #ifdef FEAT_MBYTE
2151 /* If editing a new file: set 'fenc' for the current buffer.
2152 * Also for ":read ++edit file". */
2153 if (set_options)
2154 set_string_option_direct((char_u *)"fenc", -1, fenc,
2155 OPT_FREE|OPT_LOCAL, 0);
2156 if (fenc_alloced)
2157 vim_free(fenc);
2158 # ifdef USE_ICONV
2159 if (iconv_fd != (iconv_t)-1)
2161 iconv_close(iconv_fd);
2162 iconv_fd = (iconv_t)-1;
2164 # endif
2165 #endif
2167 if (!read_buffer && !read_stdin)
2168 close(fd); /* errors are ignored */
2169 vim_free(buffer);
2171 #ifdef HAVE_DUP
2172 if (read_stdin)
2174 /* Use stderr for stdin, makes shell commands work. */
2175 close(0);
2176 dup(2);
2178 #endif
2180 #ifdef FEAT_MBYTE
2181 if (tmpname != NULL)
2183 mch_remove(tmpname); /* delete converted file */
2184 vim_free(tmpname);
2186 #endif
2187 --no_wait_return; /* may wait for return now */
2190 * In recovery mode everything but autocommands is skipped.
2192 if (!recoverymode)
2194 /* need to delete the last line, which comes from the empty buffer */
2195 if (newfile && wasempty && !(curbuf->b_ml.ml_flags & ML_EMPTY))
2197 #ifdef FEAT_NETBEANS_INTG
2198 netbeansFireChanges = 0;
2199 #endif
2200 ml_delete(curbuf->b_ml.ml_line_count, FALSE);
2201 #ifdef FEAT_NETBEANS_INTG
2202 netbeansFireChanges = 1;
2203 #endif
2204 --linecnt;
2206 linecnt = curbuf->b_ml.ml_line_count - linecnt;
2207 if (filesize == 0)
2208 linecnt = 0;
2209 if (newfile || read_buffer)
2211 redraw_curbuf_later(NOT_VALID);
2212 #ifdef FEAT_DIFF
2213 /* After reading the text into the buffer the diff info needs to
2214 * be updated. */
2215 diff_invalidate(curbuf);
2216 #endif
2217 #ifdef FEAT_FOLDING
2218 /* All folds in the window are invalid now. Mark them for update
2219 * before triggering autocommands. */
2220 foldUpdateAll(curwin);
2221 #endif
2223 else if (linecnt) /* appended at least one line */
2224 appended_lines_mark(from, linecnt);
2226 #ifndef ALWAYS_USE_GUI
2228 * If we were reading from the same terminal as where messages go,
2229 * the screen will have been messed up.
2230 * Switch on raw mode now and clear the screen.
2232 if (read_stdin)
2234 settmode(TMODE_RAW); /* set to raw mode */
2235 starttermcap();
2236 screenclear();
2238 #endif
2240 if (got_int)
2242 if (!(flags & READ_DUMMY))
2244 filemess(curbuf, sfname, (char_u *)_(e_interr), 0);
2245 if (newfile)
2246 curbuf->b_p_ro = TRUE; /* must use "w!" now */
2248 msg_scroll = msg_save;
2249 #ifdef FEAT_VIMINFO
2250 check_marks_read();
2251 #endif
2252 return OK; /* an interrupt isn't really an error */
2255 if (!filtering && !(flags & READ_DUMMY))
2257 msg_add_fname(curbuf, sfname); /* fname in IObuff with quotes */
2258 c = FALSE;
2260 #ifdef UNIX
2261 # ifdef S_ISFIFO
2262 if (S_ISFIFO(perm)) /* fifo or socket */
2264 STRCAT(IObuff, _("[fifo/socket]"));
2265 c = TRUE;
2267 # else
2268 # ifdef S_IFIFO
2269 if ((perm & S_IFMT) == S_IFIFO) /* fifo */
2271 STRCAT(IObuff, _("[fifo]"));
2272 c = TRUE;
2274 # endif
2275 # ifdef S_IFSOCK
2276 if ((perm & S_IFMT) == S_IFSOCK) /* or socket */
2278 STRCAT(IObuff, _("[socket]"));
2279 c = TRUE;
2281 # endif
2282 # endif
2283 # ifdef OPEN_CHR_FILES
2284 if (S_ISCHR(perm)) /* or character special */
2286 STRCAT(IObuff, _("[character special]"));
2287 c = TRUE;
2289 # endif
2290 #endif
2291 if (curbuf->b_p_ro)
2293 STRCAT(IObuff, shortmess(SHM_RO) ? _("[RO]") : _("[readonly]"));
2294 c = TRUE;
2296 if (read_no_eol_lnum)
2298 msg_add_eol();
2299 c = TRUE;
2301 if (ff_error == EOL_DOS)
2303 STRCAT(IObuff, _("[CR missing]"));
2304 c = TRUE;
2306 if (ff_error == EOL_MAC)
2308 STRCAT(IObuff, _("[NL found]"));
2309 c = TRUE;
2311 if (split)
2313 STRCAT(IObuff, _("[long lines split]"));
2314 c = TRUE;
2316 #ifdef FEAT_MBYTE
2317 if (notconverted)
2319 STRCAT(IObuff, _("[NOT converted]"));
2320 c = TRUE;
2322 else if (converted)
2324 STRCAT(IObuff, _("[converted]"));
2325 c = TRUE;
2327 #endif
2328 #ifdef FEAT_CRYPT
2329 if (cryptkey != NULL)
2331 STRCAT(IObuff, _("[crypted]"));
2332 c = TRUE;
2334 #endif
2335 #ifdef FEAT_MBYTE
2336 if (conv_error != 0)
2338 sprintf((char *)IObuff + STRLEN(IObuff),
2339 _("[CONVERSION ERROR in line %ld]"), (long)conv_error);
2340 c = TRUE;
2342 else if (illegal_byte > 0)
2344 sprintf((char *)IObuff + STRLEN(IObuff),
2345 _("[ILLEGAL BYTE in line %ld]"), (long)illegal_byte);
2346 c = TRUE;
2348 else
2349 #endif
2350 if (error)
2352 STRCAT(IObuff, _("[READ ERRORS]"));
2353 c = TRUE;
2355 if (msg_add_fileformat(fileformat))
2356 c = TRUE;
2357 #ifdef FEAT_CRYPT
2358 if (cryptkey != NULL)
2359 msg_add_lines(c, (long)linecnt, filesize - CRYPT_MAGIC_LEN);
2360 else
2361 #endif
2362 msg_add_lines(c, (long)linecnt, filesize);
2364 vim_free(keep_msg);
2365 keep_msg = NULL;
2366 msg_scrolled_ign = TRUE;
2367 #ifdef ALWAYS_USE_GUI
2368 /* Don't show the message when reading stdin, it would end up in a
2369 * message box (which might be shown when exiting!) */
2370 if (read_stdin || read_buffer)
2371 p = msg_may_trunc(FALSE, IObuff);
2372 else
2373 #endif
2374 p = msg_trunc_attr(IObuff, FALSE, 0);
2375 if (read_stdin || read_buffer || restart_edit != 0
2376 || (msg_scrolled != 0 && !need_wait_return))
2377 /* Need to repeat the message after redrawing when:
2378 * - When reading from stdin (the screen will be cleared next).
2379 * - When restart_edit is set (otherwise there will be a delay
2380 * before redrawing).
2381 * - When the screen was scrolled but there is no wait-return
2382 * prompt. */
2383 set_keep_msg(p, 0);
2384 msg_scrolled_ign = FALSE;
2387 /* with errors writing the file requires ":w!" */
2388 if (newfile && (error
2389 #ifdef FEAT_MBYTE
2390 || conv_error != 0
2391 || (illegal_byte > 0 && bad_char_behavior != BAD_KEEP)
2392 #endif
2394 curbuf->b_p_ro = TRUE;
2396 u_clearline(); /* cannot use "U" command after adding lines */
2399 * In Ex mode: cursor at last new line.
2400 * Otherwise: cursor at first new line.
2402 if (exmode_active)
2403 curwin->w_cursor.lnum = from + linecnt;
2404 else
2405 curwin->w_cursor.lnum = from + 1;
2406 check_cursor_lnum();
2407 beginline(BL_WHITE | BL_FIX); /* on first non-blank */
2410 * Set '[ and '] marks to the newly read lines.
2412 curbuf->b_op_start.lnum = from + 1;
2413 curbuf->b_op_start.col = 0;
2414 curbuf->b_op_end.lnum = from + linecnt;
2415 curbuf->b_op_end.col = 0;
2417 #ifdef WIN32
2419 * Work around a weird problem: When a file has two links (only
2420 * possible on NTFS) and we write through one link, then stat() it
2421 * throught the other link, the timestamp information may be wrong.
2422 * It's correct again after reading the file, thus reset the timestamp
2423 * here.
2425 if (newfile && !read_stdin && !read_buffer
2426 && mch_stat((char *)fname, &st) >= 0)
2428 buf_store_time(curbuf, &st, fname);
2429 curbuf->b_mtime_read = curbuf->b_mtime;
2431 #endif
2433 msg_scroll = msg_save;
2435 #ifdef FEAT_VIMINFO
2437 * Get the marks before executing autocommands, so they can be used there.
2439 check_marks_read();
2440 #endif
2443 * Trick: We remember if the last line of the read didn't have
2444 * an eol for when writing it again. This is required for
2445 * ":autocmd FileReadPost *.gz set bin|'[,']!gunzip" to work.
2447 write_no_eol_lnum = read_no_eol_lnum;
2449 #ifdef FEAT_AUTOCMD
2450 if (!read_stdin && !read_buffer)
2452 int m = msg_scroll;
2453 int n = msg_scrolled;
2455 /* Save the fileformat now, otherwise the buffer will be considered
2456 * modified if the format/encoding was automatically detected. */
2457 if (set_options)
2458 save_file_ff(curbuf);
2461 * The output from the autocommands should not overwrite anything and
2462 * should not be overwritten: Set msg_scroll, restore its value if no
2463 * output was done.
2465 msg_scroll = TRUE;
2466 if (filtering)
2467 apply_autocmds_exarg(EVENT_FILTERREADPOST, NULL, sfname,
2468 FALSE, curbuf, eap);
2469 else if (newfile)
2470 apply_autocmds_exarg(EVENT_BUFREADPOST, NULL, sfname,
2471 FALSE, curbuf, eap);
2472 else
2473 apply_autocmds_exarg(EVENT_FILEREADPOST, sfname, sfname,
2474 FALSE, NULL, eap);
2475 if (msg_scrolled == n)
2476 msg_scroll = m;
2477 #ifdef FEAT_EVAL
2478 if (aborting()) /* autocmds may abort script processing */
2479 return FAIL;
2480 #endif
2482 #endif
2484 if (recoverymode && error)
2485 return FAIL;
2486 return OK;
2489 #ifdef OPEN_CHR_FILES
2491 * Returns TRUE if the file name argument is of the form "/dev/fd/\d\+",
2492 * which is the name of files used for process substitution output by
2493 * some shells on some operating systems, e.g., bash on SunOS.
2494 * Do not accept "/dev/fd/[012]", opening these may hang Vim.
2496 static int
2497 is_dev_fd_file(fname)
2498 char_u *fname;
2500 return (STRNCMP(fname, "/dev/fd/", 8) == 0
2501 && VIM_ISDIGIT(fname[8])
2502 && *skipdigits(fname + 9) == NUL
2503 && (fname[9] != NUL
2504 || (fname[8] != '0' && fname[8] != '1' && fname[8] != '2')));
2506 #endif
2508 #ifdef FEAT_MBYTE
2511 * From the current line count and characters read after that, estimate the
2512 * line number where we are now.
2513 * Used for error messages that include a line number.
2515 static linenr_T
2516 readfile_linenr(linecnt, p, endp)
2517 linenr_T linecnt; /* line count before reading more bytes */
2518 char_u *p; /* start of more bytes read */
2519 char_u *endp; /* end of more bytes read */
2521 char_u *s;
2522 linenr_T lnum;
2524 lnum = curbuf->b_ml.ml_line_count - linecnt + 1;
2525 for (s = p; s < endp; ++s)
2526 if (*s == '\n')
2527 ++lnum;
2528 return lnum;
2530 #endif
2533 * Fill "*eap" to force the 'fileencoding', 'fileformat' and 'binary to be
2534 * equal to the buffer "buf". Used for calling readfile().
2535 * Returns OK or FAIL.
2538 prep_exarg(eap, buf)
2539 exarg_T *eap;
2540 buf_T *buf;
2542 eap->cmd = alloc((unsigned)(STRLEN(buf->b_p_ff)
2543 #ifdef FEAT_MBYTE
2544 + STRLEN(buf->b_p_fenc)
2545 #endif
2546 + 15));
2547 if (eap->cmd == NULL)
2548 return FAIL;
2550 #ifdef FEAT_MBYTE
2551 sprintf((char *)eap->cmd, "e ++ff=%s ++enc=%s", buf->b_p_ff, buf->b_p_fenc);
2552 eap->force_enc = 14 + (int)STRLEN(buf->b_p_ff);
2553 eap->bad_char = buf->b_bad_char;
2554 #else
2555 sprintf((char *)eap->cmd, "e ++ff=%s", buf->b_p_ff);
2556 #endif
2557 eap->force_ff = 7;
2559 eap->force_bin = buf->b_p_bin ? FORCE_BIN : FORCE_NOBIN;
2560 eap->read_edit = FALSE;
2561 eap->forceit = FALSE;
2562 return OK;
2565 #ifdef FEAT_MBYTE
2567 * Find next fileencoding to use from 'fileencodings'.
2568 * "pp" points to fenc_next. It's advanced to the next item.
2569 * When there are no more items, an empty string is returned and *pp is set to
2570 * NULL.
2571 * When *pp is not set to NULL, the result is in allocated memory.
2573 static char_u *
2574 next_fenc(pp)
2575 char_u **pp;
2577 char_u *p;
2578 char_u *r;
2580 if (**pp == NUL)
2582 *pp = NULL;
2583 return (char_u *)"";
2585 p = vim_strchr(*pp, ',');
2586 if (p == NULL)
2588 r = enc_canonize(*pp);
2589 *pp += STRLEN(*pp);
2591 else
2593 r = vim_strnsave(*pp, (int)(p - *pp));
2594 *pp = p + 1;
2595 if (r != NULL)
2597 p = enc_canonize(r);
2598 vim_free(r);
2599 r = p;
2602 if (r == NULL) /* out of memory */
2604 r = (char_u *)"";
2605 *pp = NULL;
2607 return r;
2610 # ifdef FEAT_EVAL
2612 * Convert a file with the 'charconvert' expression.
2613 * This closes the file which is to be read, converts it and opens the
2614 * resulting file for reading.
2615 * Returns name of the resulting converted file (the caller should delete it
2616 * after reading it).
2617 * Returns NULL if the conversion failed ("*fdp" is not set) .
2619 static char_u *
2620 readfile_charconvert(fname, fenc, fdp)
2621 char_u *fname; /* name of input file */
2622 char_u *fenc; /* converted from */
2623 int *fdp; /* in/out: file descriptor of file */
2625 char_u *tmpname;
2626 char_u *errmsg = NULL;
2628 tmpname = vim_tempname('r');
2629 if (tmpname == NULL)
2630 errmsg = (char_u *)_("Can't find temp file for conversion");
2631 else
2633 close(*fdp); /* close the input file, ignore errors */
2634 *fdp = -1;
2635 if (eval_charconvert(fenc, enc_utf8 ? (char_u *)"utf-8" : p_enc,
2636 fname, tmpname) == FAIL)
2637 errmsg = (char_u *)_("Conversion with 'charconvert' failed");
2638 if (errmsg == NULL && (*fdp = mch_open((char *)tmpname,
2639 O_RDONLY | O_EXTRA, 0)) < 0)
2640 errmsg = (char_u *)_("can't read output of 'charconvert'");
2643 if (errmsg != NULL)
2645 /* Don't use emsg(), it breaks mappings, the retry with
2646 * another type of conversion might still work. */
2647 MSG(errmsg);
2648 if (tmpname != NULL)
2650 mch_remove(tmpname); /* delete converted file */
2651 vim_free(tmpname);
2652 tmpname = NULL;
2656 /* If the input file is closed, open it (caller should check for error). */
2657 if (*fdp < 0)
2658 *fdp = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
2660 return tmpname;
2662 # endif
2664 #endif
2666 #ifdef FEAT_VIMINFO
2668 * Read marks for the current buffer from the viminfo file, when we support
2669 * buffer marks and the buffer has a name.
2671 static void
2672 check_marks_read()
2674 if (!curbuf->b_marks_read && get_viminfo_parameter('\'') > 0
2675 && curbuf->b_ffname != NULL)
2676 read_viminfo(NULL, FALSE, TRUE, FALSE);
2678 /* Always set b_marks_read; needed when 'viminfo' is changed to include
2679 * the ' parameter after opening a buffer. */
2680 curbuf->b_marks_read = TRUE;
2682 #endif
2684 #ifdef FEAT_CRYPT
2686 * Check for magic number used for encryption.
2687 * If found, the magic number is removed from ptr[*sizep] and *sizep and
2688 * *filesizep are updated.
2689 * Return the (new) encryption key, NULL for no encryption.
2691 static char_u *
2692 check_for_cryptkey(cryptkey, ptr, sizep, filesizep, newfile)
2693 char_u *cryptkey; /* previous encryption key or NULL */
2694 char_u *ptr; /* pointer to read bytes */
2695 long *sizep; /* length of read bytes */
2696 long *filesizep; /* nr of bytes used from file */
2697 int newfile; /* editing a new buffer */
2699 if (*sizep >= CRYPT_MAGIC_LEN
2700 && STRNCMP(ptr, CRYPT_MAGIC, CRYPT_MAGIC_LEN) == 0)
2702 if (cryptkey == NULL)
2704 if (*curbuf->b_p_key)
2705 cryptkey = curbuf->b_p_key;
2706 else
2708 /* When newfile is TRUE, store the typed key
2709 * in the 'key' option and don't free it. */
2710 cryptkey = get_crypt_key(newfile, FALSE);
2711 /* check if empty key entered */
2712 if (cryptkey != NULL && *cryptkey == NUL)
2714 if (cryptkey != curbuf->b_p_key)
2715 vim_free(cryptkey);
2716 cryptkey = NULL;
2721 if (cryptkey != NULL)
2723 crypt_init_keys(cryptkey);
2725 /* Remove magic number from the text */
2726 *filesizep += CRYPT_MAGIC_LEN;
2727 *sizep -= CRYPT_MAGIC_LEN;
2728 mch_memmove(ptr, ptr + CRYPT_MAGIC_LEN, (size_t)*sizep);
2731 /* When starting to edit a new file which does not have
2732 * encryption, clear the 'key' option, except when
2733 * starting up (called with -x argument) */
2734 else if (newfile && *curbuf->b_p_key && !starting)
2735 set_option_value((char_u *)"key", 0L, (char_u *)"", OPT_LOCAL);
2737 return cryptkey;
2739 #endif
2741 #ifdef UNIX
2742 static void
2743 set_file_time(fname, atime, mtime)
2744 char_u *fname;
2745 time_t atime; /* access time */
2746 time_t mtime; /* modification time */
2748 # if defined(HAVE_UTIME) && defined(HAVE_UTIME_H)
2749 struct utimbuf buf;
2751 buf.actime = atime;
2752 buf.modtime = mtime;
2753 (void)utime((char *)fname, &buf);
2754 # else
2755 # if defined(HAVE_UTIMES)
2756 struct timeval tvp[2];
2758 tvp[0].tv_sec = atime;
2759 tvp[0].tv_usec = 0;
2760 tvp[1].tv_sec = mtime;
2761 tvp[1].tv_usec = 0;
2762 # ifdef NeXT
2763 (void)utimes((char *)fname, tvp);
2764 # else
2765 (void)utimes((char *)fname, (const struct timeval *)&tvp);
2766 # endif
2767 # endif
2768 # endif
2770 #endif /* UNIX */
2772 #if defined(VMS) && !defined(MIN)
2773 /* Older DECC compiler for VAX doesn't define MIN() */
2774 # define MIN(a, b) ((a) < (b) ? (a) : (b))
2775 #endif
2778 * Return TRUE if a file appears to be read-only from the file permissions.
2781 check_file_readonly(fname, perm)
2782 char_u *fname; /* full path to file */
2783 int perm; /* known permissions on file */
2785 #ifndef USE_MCH_ACCESS
2786 int fd = 0;
2787 #endif
2789 return (
2790 #ifdef USE_MCH_ACCESS
2791 # ifdef UNIX
2792 (perm & 0222) == 0 ||
2793 # endif
2794 mch_access((char *)fname, W_OK)
2795 #else
2796 (fd = mch_open((char *)fname, O_RDWR | O_EXTRA, 0)) < 0
2797 ? TRUE : (close(fd), FALSE)
2798 #endif
2804 * buf_write() - write to file "fname" lines "start" through "end"
2806 * We do our own buffering here because fwrite() is so slow.
2808 * If "forceit" is true, we don't care for errors when attempting backups.
2809 * In case of an error everything possible is done to restore the original
2810 * file. But when "forceit" is TRUE, we risk loosing it.
2812 * When "reset_changed" is TRUE and "append" == FALSE and "start" == 1 and
2813 * "end" == curbuf->b_ml.ml_line_count, reset curbuf->b_changed.
2815 * This function must NOT use NameBuff (because it's called by autowrite()).
2817 * return FAIL for failure, OK otherwise
2820 buf_write(buf, fname, sfname, start, end, eap, append, forceit,
2821 reset_changed, filtering)
2822 buf_T *buf;
2823 char_u *fname;
2824 char_u *sfname;
2825 linenr_T start, end;
2826 exarg_T *eap; /* for forced 'ff' and 'fenc', can be
2827 NULL! */
2828 int append; /* append to the file */
2829 int forceit;
2830 int reset_changed;
2831 int filtering;
2833 int fd;
2834 char_u *backup = NULL;
2835 int backup_copy = FALSE; /* copy the original file? */
2836 int dobackup;
2837 char_u *ffname;
2838 char_u *wfname = NULL; /* name of file to write to */
2839 char_u *s;
2840 char_u *ptr;
2841 char_u c;
2842 int len;
2843 linenr_T lnum;
2844 long nchars;
2845 char_u *errmsg = NULL;
2846 char_u *errnum = NULL;
2847 char_u *buffer;
2848 char_u smallbuf[SMBUFSIZE];
2849 char_u *backup_ext;
2850 int bufsize;
2851 long perm; /* file permissions */
2852 int retval = OK;
2853 int newfile = FALSE; /* TRUE if file doesn't exist yet */
2854 int msg_save = msg_scroll;
2855 int overwriting; /* TRUE if writing over original */
2856 int no_eol = FALSE; /* no end-of-line written */
2857 int device = FALSE; /* writing to a device */
2858 struct stat st_old;
2859 int prev_got_int = got_int;
2860 int file_readonly = FALSE; /* overwritten file is read-only */
2861 static char *err_readonly = "is read-only (cannot override: \"W\" in 'cpoptions')";
2862 #if defined(UNIX) || defined(__EMX__XX) /*XXX fix me sometime? */
2863 int made_writable = FALSE; /* 'w' bit has been set */
2864 #endif
2865 /* writing everything */
2866 int whole = (start == 1 && end == buf->b_ml.ml_line_count);
2867 #ifdef FEAT_AUTOCMD
2868 linenr_T old_line_count = buf->b_ml.ml_line_count;
2869 #endif
2870 int attr;
2871 int fileformat;
2872 int write_bin;
2873 struct bw_info write_info; /* info for buf_write_bytes() */
2874 #ifdef FEAT_MBYTE
2875 int converted = FALSE;
2876 int notconverted = FALSE;
2877 char_u *fenc; /* effective 'fileencoding' */
2878 char_u *fenc_tofree = NULL; /* allocated "fenc" */
2879 #endif
2880 #ifdef HAS_BW_FLAGS
2881 int wb_flags = 0;
2882 #endif
2883 #ifdef HAVE_ACL
2884 vim_acl_T acl = NULL; /* ACL copied from original file to
2885 backup or new file */
2886 #endif
2888 if (fname == NULL || *fname == NUL) /* safety check */
2889 return FAIL;
2892 * Disallow writing from .exrc and .vimrc in current directory for
2893 * security reasons.
2895 if (check_secure())
2896 return FAIL;
2898 /* Avoid a crash for a long name. */
2899 if (STRLEN(fname) >= MAXPATHL)
2901 EMSG(_(e_longname));
2902 return FAIL;
2905 #ifdef FEAT_MBYTE
2906 /* must init bw_conv_buf and bw_iconv_fd before jumping to "fail" */
2907 write_info.bw_conv_buf = NULL;
2908 write_info.bw_conv_error = FALSE;
2909 write_info.bw_restlen = 0;
2910 # ifdef USE_ICONV
2911 write_info.bw_iconv_fd = (iconv_t)-1;
2912 # endif
2913 #endif
2915 /* After writing a file changedtick changes but we don't want to display
2916 * the line. */
2917 ex_no_reprint = TRUE;
2920 * If there is no file name yet, use the one for the written file.
2921 * BF_NOTEDITED is set to reflect this (in case the write fails).
2922 * Don't do this when the write is for a filter command.
2923 * Don't do this when appending.
2924 * Only do this when 'cpoptions' contains the 'F' flag.
2926 if (buf->b_ffname == NULL
2927 && reset_changed
2928 && whole
2929 && buf == curbuf
2930 #ifdef FEAT_QUICKFIX
2931 && !bt_nofile(buf)
2932 #endif
2933 && !filtering
2934 && (!append || vim_strchr(p_cpo, CPO_FNAMEAPP) != NULL)
2935 && vim_strchr(p_cpo, CPO_FNAMEW) != NULL)
2937 if (set_rw_fname(fname, sfname) == FAIL)
2938 return FAIL;
2939 buf = curbuf; /* just in case autocmds made "buf" invalid */
2942 if (sfname == NULL)
2943 sfname = fname;
2945 * For Unix: Use the short file name whenever possible.
2946 * Avoids problems with networks and when directory names are changed.
2947 * Don't do this for MS-DOS, a "cd" in a sub-shell may have moved us to
2948 * another directory, which we don't detect
2950 ffname = fname; /* remember full fname */
2951 #ifdef UNIX
2952 fname = sfname;
2953 #endif
2955 if (buf->b_ffname != NULL && fnamecmp(ffname, buf->b_ffname) == 0)
2956 overwriting = TRUE;
2957 else
2958 overwriting = FALSE;
2960 if (exiting)
2961 settmode(TMODE_COOK); /* when exiting allow typahead now */
2963 ++no_wait_return; /* don't wait for return yet */
2966 * Set '[ and '] marks to the lines to be written.
2968 buf->b_op_start.lnum = start;
2969 buf->b_op_start.col = 0;
2970 buf->b_op_end.lnum = end;
2971 buf->b_op_end.col = 0;
2973 #ifdef FEAT_AUTOCMD
2975 aco_save_T aco;
2976 int buf_ffname = FALSE;
2977 int buf_sfname = FALSE;
2978 int buf_fname_f = FALSE;
2979 int buf_fname_s = FALSE;
2980 int did_cmd = FALSE;
2981 int nofile_err = FALSE;
2982 int empty_memline = (buf->b_ml.ml_mfp == NULL);
2985 * Apply PRE aucocommands.
2986 * Set curbuf to the buffer to be written.
2987 * Careful: The autocommands may call buf_write() recursively!
2989 if (ffname == buf->b_ffname)
2990 buf_ffname = TRUE;
2991 if (sfname == buf->b_sfname)
2992 buf_sfname = TRUE;
2993 if (fname == buf->b_ffname)
2994 buf_fname_f = TRUE;
2995 if (fname == buf->b_sfname)
2996 buf_fname_s = TRUE;
2998 /* set curwin/curbuf to buf and save a few things */
2999 aucmd_prepbuf(&aco, buf);
3001 if (append)
3003 if (!(did_cmd = apply_autocmds_exarg(EVENT_FILEAPPENDCMD,
3004 sfname, sfname, FALSE, curbuf, eap)))
3006 #ifdef FEAT_QUICKFIX
3007 if (overwriting && bt_nofile(curbuf))
3008 nofile_err = TRUE;
3009 else
3010 #endif
3011 apply_autocmds_exarg(EVENT_FILEAPPENDPRE,
3012 sfname, sfname, FALSE, curbuf, eap);
3015 else if (filtering)
3017 apply_autocmds_exarg(EVENT_FILTERWRITEPRE,
3018 NULL, sfname, FALSE, curbuf, eap);
3020 else if (reset_changed && whole)
3022 if (!(did_cmd = apply_autocmds_exarg(EVENT_BUFWRITECMD,
3023 sfname, sfname, FALSE, curbuf, eap)))
3025 #ifdef FEAT_QUICKFIX
3026 if (overwriting && bt_nofile(curbuf))
3027 nofile_err = TRUE;
3028 else
3029 #endif
3030 apply_autocmds_exarg(EVENT_BUFWRITEPRE,
3031 sfname, sfname, FALSE, curbuf, eap);
3034 else
3036 if (!(did_cmd = apply_autocmds_exarg(EVENT_FILEWRITECMD,
3037 sfname, sfname, FALSE, curbuf, eap)))
3039 #ifdef FEAT_QUICKFIX
3040 if (overwriting && bt_nofile(curbuf))
3041 nofile_err = TRUE;
3042 else
3043 #endif
3044 apply_autocmds_exarg(EVENT_FILEWRITEPRE,
3045 sfname, sfname, FALSE, curbuf, eap);
3049 /* restore curwin/curbuf and a few other things */
3050 aucmd_restbuf(&aco);
3053 * In three situations we return here and don't write the file:
3054 * 1. the autocommands deleted or unloaded the buffer.
3055 * 2. The autocommands abort script processing.
3056 * 3. If one of the "Cmd" autocommands was executed.
3058 if (!buf_valid(buf))
3059 buf = NULL;
3060 if (buf == NULL || (buf->b_ml.ml_mfp == NULL && !empty_memline)
3061 || did_cmd || nofile_err
3062 #ifdef FEAT_EVAL
3063 || aborting()
3064 #endif
3067 --no_wait_return;
3068 msg_scroll = msg_save;
3069 if (nofile_err)
3070 EMSG(_("E676: No matching autocommands for acwrite buffer"));
3072 if (nofile_err
3073 #ifdef FEAT_EVAL
3074 || aborting()
3075 #endif
3077 /* An aborting error, interrupt or exception in the
3078 * autocommands. */
3079 return FAIL;
3080 if (did_cmd)
3082 if (buf == NULL)
3083 /* The buffer was deleted. We assume it was written
3084 * (can't retry anyway). */
3085 return OK;
3086 if (overwriting)
3088 /* Assume the buffer was written, update the timestamp. */
3089 ml_timestamp(buf);
3090 if (append)
3091 buf->b_flags &= ~BF_NEW;
3092 else
3093 buf->b_flags &= ~BF_WRITE_MASK;
3095 if (reset_changed && buf->b_changed && !append
3096 && (overwriting || vim_strchr(p_cpo, CPO_PLUS) != NULL))
3097 /* Buffer still changed, the autocommands didn't work
3098 * properly. */
3099 return FAIL;
3100 return OK;
3102 #ifdef FEAT_EVAL
3103 if (!aborting())
3104 #endif
3105 EMSG(_("E203: Autocommands deleted or unloaded buffer to be written"));
3106 return FAIL;
3110 * The autocommands may have changed the number of lines in the file.
3111 * When writing the whole file, adjust the end.
3112 * When writing part of the file, assume that the autocommands only
3113 * changed the number of lines that are to be written (tricky!).
3115 if (buf->b_ml.ml_line_count != old_line_count)
3117 if (whole) /* write all */
3118 end = buf->b_ml.ml_line_count;
3119 else if (buf->b_ml.ml_line_count > old_line_count) /* more lines */
3120 end += buf->b_ml.ml_line_count - old_line_count;
3121 else /* less lines */
3123 end -= old_line_count - buf->b_ml.ml_line_count;
3124 if (end < start)
3126 --no_wait_return;
3127 msg_scroll = msg_save;
3128 EMSG(_("E204: Autocommand changed number of lines in unexpected way"));
3129 return FAIL;
3135 * The autocommands may have changed the name of the buffer, which may
3136 * be kept in fname, ffname and sfname.
3138 if (buf_ffname)
3139 ffname = buf->b_ffname;
3140 if (buf_sfname)
3141 sfname = buf->b_sfname;
3142 if (buf_fname_f)
3143 fname = buf->b_ffname;
3144 if (buf_fname_s)
3145 fname = buf->b_sfname;
3147 #endif
3149 #ifdef FEAT_NETBEANS_INTG
3150 if (usingNetbeans && isNetbeansBuffer(buf))
3152 if (whole)
3155 * b_changed can be 0 after an undo, but we still need to write
3156 * the buffer to NetBeans.
3158 if (buf->b_changed || isNetbeansModified(buf))
3160 --no_wait_return; /* may wait for return now */
3161 msg_scroll = msg_save;
3162 netbeans_save_buffer(buf); /* no error checking... */
3163 return retval;
3165 else
3167 errnum = (char_u *)"E656: ";
3168 errmsg = (char_u *)_("NetBeans dissallows writes of unmodified buffers");
3169 buffer = NULL;
3170 goto fail;
3173 else
3175 errnum = (char_u *)"E657: ";
3176 errmsg = (char_u *)_("Partial writes disallowed for NetBeans buffers");
3177 buffer = NULL;
3178 goto fail;
3181 #endif
3183 if (shortmess(SHM_OVER) && !exiting)
3184 msg_scroll = FALSE; /* overwrite previous file message */
3185 else
3186 msg_scroll = TRUE; /* don't overwrite previous file message */
3187 if (!filtering)
3188 filemess(buf,
3189 #ifndef UNIX
3190 sfname,
3191 #else
3192 fname,
3193 #endif
3194 (char_u *)"", 0); /* show that we are busy */
3195 msg_scroll = FALSE; /* always overwrite the file message now */
3197 buffer = alloc(BUFSIZE);
3198 if (buffer == NULL) /* can't allocate big buffer, use small
3199 * one (to be able to write when out of
3200 * memory) */
3202 buffer = smallbuf;
3203 bufsize = SMBUFSIZE;
3205 else
3206 bufsize = BUFSIZE;
3209 * Get information about original file (if there is one).
3211 #if defined(UNIX) && !defined(ARCHIE)
3212 st_old.st_dev = 0;
3213 st_old.st_ino = 0;
3214 perm = -1;
3215 if (mch_stat((char *)fname, &st_old) < 0)
3216 newfile = TRUE;
3217 else
3219 perm = st_old.st_mode;
3220 if (!S_ISREG(st_old.st_mode)) /* not a file */
3222 if (S_ISDIR(st_old.st_mode))
3224 errnum = (char_u *)"E502: ";
3225 errmsg = (char_u *)_("is a directory");
3226 goto fail;
3228 if (mch_nodetype(fname) != NODE_WRITABLE)
3230 errnum = (char_u *)"E503: ";
3231 errmsg = (char_u *)_("is not a file or writable device");
3232 goto fail;
3234 /* It's a device of some kind (or a fifo) which we can write to
3235 * but for which we can't make a backup. */
3236 device = TRUE;
3237 newfile = TRUE;
3238 perm = -1;
3241 #else /* !UNIX */
3243 * Check for a writable device name.
3245 c = mch_nodetype(fname);
3246 if (c == NODE_OTHER)
3248 errnum = (char_u *)"E503: ";
3249 errmsg = (char_u *)_("is not a file or writable device");
3250 goto fail;
3252 if (c == NODE_WRITABLE)
3254 # if defined(MSDOS) || defined(MSWIN) || defined(OS2)
3255 /* MS-Windows allows opening a device, but we will probably get stuck
3256 * trying to write to it. */
3257 if (!p_odev)
3259 errnum = (char_u *)"E796: ";
3260 errmsg = (char_u *)_("writing to device disabled with 'opendevice' option");
3261 goto fail;
3263 # endif
3264 device = TRUE;
3265 newfile = TRUE;
3266 perm = -1;
3268 else
3270 perm = mch_getperm(fname);
3271 if (perm < 0)
3272 newfile = TRUE;
3273 else if (mch_isdir(fname))
3275 errnum = (char_u *)"E502: ";
3276 errmsg = (char_u *)_("is a directory");
3277 goto fail;
3279 if (overwriting)
3280 (void)mch_stat((char *)fname, &st_old);
3282 #endif /* !UNIX */
3284 if (!device && !newfile)
3287 * Check if the file is really writable (when renaming the file to
3288 * make a backup we won't discover it later).
3290 file_readonly = check_file_readonly(fname, (int)perm);
3292 if (!forceit && file_readonly)
3294 if (vim_strchr(p_cpo, CPO_FWRITE) != NULL)
3296 errnum = (char_u *)"E504: ";
3297 errmsg = (char_u *)_(err_readonly);
3299 else
3301 errnum = (char_u *)"E505: ";
3302 errmsg = (char_u *)_("is read-only (add ! to override)");
3304 goto fail;
3308 * Check if the timestamp hasn't changed since reading the file.
3310 if (overwriting)
3312 retval = check_mtime(buf, &st_old);
3313 if (retval == FAIL)
3314 goto fail;
3318 #ifdef HAVE_ACL
3320 * For systems that support ACL: get the ACL from the original file.
3322 if (!newfile)
3323 acl = mch_get_acl(fname);
3324 #endif
3327 * If 'backupskip' is not empty, don't make a backup for some files.
3329 dobackup = (p_wb || p_bk || *p_pm != NUL);
3330 #ifdef FEAT_WILDIGN
3331 if (dobackup && *p_bsk != NUL && match_file_list(p_bsk, sfname, ffname))
3332 dobackup = FALSE;
3333 #endif
3336 * Save the value of got_int and reset it. We don't want a previous
3337 * interruption cancel writing, only hitting CTRL-C while writing should
3338 * abort it.
3340 prev_got_int = got_int;
3341 got_int = FALSE;
3343 /* Mark the buffer as 'being saved' to prevent changed buffer warnings */
3344 buf->b_saving = TRUE;
3347 * If we are not appending or filtering, the file exists, and the
3348 * 'writebackup', 'backup' or 'patchmode' option is set, need a backup.
3349 * When 'patchmode' is set also make a backup when appending.
3351 * Do not make any backup, if 'writebackup' and 'backup' are both switched
3352 * off. This helps when editing large files on almost-full disks.
3354 if (!(append && *p_pm == NUL) && !filtering && perm >= 0 && dobackup)
3356 #if defined(UNIX) || defined(WIN32)
3357 struct stat st;
3358 #endif
3360 if ((bkc_flags & BKC_YES) || append) /* "yes" */
3361 backup_copy = TRUE;
3362 #if defined(UNIX) || defined(WIN32)
3363 else if ((bkc_flags & BKC_AUTO)) /* "auto" */
3365 int i;
3367 # ifdef UNIX
3369 * Don't rename the file when:
3370 * - it's a hard link
3371 * - it's a symbolic link
3372 * - we don't have write permission in the directory
3373 * - we can't set the owner/group of the new file
3375 if (st_old.st_nlink > 1
3376 || mch_lstat((char *)fname, &st) < 0
3377 || st.st_dev != st_old.st_dev
3378 || st.st_ino != st_old.st_ino
3379 # ifndef HAVE_FCHOWN
3380 || st.st_uid != st_old.st_uid
3381 || st.st_gid != st_old.st_gid
3382 # endif
3384 backup_copy = TRUE;
3385 else
3386 # else
3387 # ifdef WIN32
3388 /* On NTFS file systems hard links are possible. */
3389 if (mch_is_linked(fname))
3390 backup_copy = TRUE;
3391 else
3392 # endif
3393 # endif
3396 * Check if we can create a file and set the owner/group to
3397 * the ones from the original file.
3398 * First find a file name that doesn't exist yet (use some
3399 * arbitrary numbers).
3401 STRCPY(IObuff, fname);
3402 for (i = 4913; ; i += 123)
3404 sprintf((char *)gettail(IObuff), "%d", i);
3405 if (mch_lstat((char *)IObuff, &st) < 0)
3406 break;
3408 fd = mch_open((char *)IObuff,
3409 O_CREAT|O_WRONLY|O_EXCL|O_NOFOLLOW, perm);
3410 if (fd < 0) /* can't write in directory */
3411 backup_copy = TRUE;
3412 else
3414 # ifdef UNIX
3415 # ifdef HAVE_FCHOWN
3416 fchown(fd, st_old.st_uid, st_old.st_gid);
3417 # endif
3418 if (mch_stat((char *)IObuff, &st) < 0
3419 || st.st_uid != st_old.st_uid
3420 || st.st_gid != st_old.st_gid
3421 || st.st_mode != perm)
3422 backup_copy = TRUE;
3423 # endif
3424 /* Close the file before removing it, on MS-Windows we
3425 * can't delete an open file. */
3426 close(fd);
3427 mch_remove(IObuff);
3432 # ifdef UNIX
3434 * Break symlinks and/or hardlinks if we've been asked to.
3436 if ((bkc_flags & BKC_BREAKSYMLINK) || (bkc_flags & BKC_BREAKHARDLINK))
3438 int lstat_res;
3440 lstat_res = mch_lstat((char *)fname, &st);
3442 /* Symlinks. */
3443 if ((bkc_flags & BKC_BREAKSYMLINK)
3444 && lstat_res == 0
3445 && st.st_ino != st_old.st_ino)
3446 backup_copy = FALSE;
3448 /* Hardlinks. */
3449 if ((bkc_flags & BKC_BREAKHARDLINK)
3450 && st_old.st_nlink > 1
3451 && (lstat_res != 0 || st.st_ino == st_old.st_ino))
3452 backup_copy = FALSE;
3454 #endif
3456 #endif
3458 /* make sure we have a valid backup extension to use */
3459 if (*p_bex == NUL)
3461 #ifdef RISCOS
3462 backup_ext = (char_u *)"/bak";
3463 #else
3464 backup_ext = (char_u *)".bak";
3465 #endif
3467 else
3468 backup_ext = p_bex;
3470 if (backup_copy
3471 && (fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0)) >= 0)
3473 int bfd;
3474 char_u *copybuf, *wp;
3475 int some_error = FALSE;
3476 struct stat st_new;
3477 char_u *dirp;
3478 char_u *rootname;
3479 #if defined(UNIX) && !defined(SHORT_FNAME)
3480 int did_set_shortname;
3481 #endif
3483 copybuf = alloc(BUFSIZE + 1);
3484 if (copybuf == NULL)
3486 some_error = TRUE; /* out of memory */
3487 goto nobackup;
3491 * Try to make the backup in each directory in the 'bdir' option.
3493 * Unix semantics has it, that we may have a writable file,
3494 * that cannot be recreated with a simple open(..., O_CREAT, ) e.g:
3495 * - the directory is not writable,
3496 * - the file may be a symbolic link,
3497 * - the file may belong to another user/group, etc.
3499 * For these reasons, the existing writable file must be truncated
3500 * and reused. Creation of a backup COPY will be attempted.
3502 dirp = p_bdir;
3503 while (*dirp)
3505 #ifdef UNIX
3506 st_new.st_ino = 0;
3507 st_new.st_dev = 0;
3508 st_new.st_gid = 0;
3509 #endif
3512 * Isolate one directory name, using an entry in 'bdir'.
3514 (void)copy_option_part(&dirp, copybuf, BUFSIZE, ",");
3515 rootname = get_file_in_dir(fname, copybuf);
3516 if (rootname == NULL)
3518 some_error = TRUE; /* out of memory */
3519 goto nobackup;
3522 #if defined(UNIX) && !defined(SHORT_FNAME)
3523 did_set_shortname = FALSE;
3524 #endif
3527 * May try twice if 'shortname' not set.
3529 for (;;)
3532 * Make backup file name.
3534 backup = buf_modname(
3535 #ifdef SHORT_FNAME
3536 TRUE,
3537 #else
3538 (buf->b_p_sn || buf->b_shortname),
3539 #endif
3540 rootname, backup_ext, FALSE);
3541 if (backup == NULL)
3543 vim_free(rootname);
3544 some_error = TRUE; /* out of memory */
3545 goto nobackup;
3549 * Check if backup file already exists.
3551 if (mch_stat((char *)backup, &st_new) >= 0)
3553 #ifdef UNIX
3555 * Check if backup file is same as original file.
3556 * May happen when modname() gave the same file back.
3557 * E.g. silly link, or file name-length reached.
3558 * If we don't check here, we either ruin the file
3559 * when copying or erase it after writing. jw.
3561 if (st_new.st_dev == st_old.st_dev
3562 && st_new.st_ino == st_old.st_ino)
3564 vim_free(backup);
3565 backup = NULL; /* no backup file to delete */
3566 # ifndef SHORT_FNAME
3568 * may try again with 'shortname' set
3570 if (!(buf->b_shortname || buf->b_p_sn))
3572 buf->b_shortname = TRUE;
3573 did_set_shortname = TRUE;
3574 continue;
3576 /* setting shortname didn't help */
3577 if (did_set_shortname)
3578 buf->b_shortname = FALSE;
3579 # endif
3580 break;
3582 #endif
3585 * If we are not going to keep the backup file, don't
3586 * delete an existing one, try to use another name.
3587 * Change one character, just before the extension.
3589 if (!p_bk)
3591 wp = backup + STRLEN(backup) - 1
3592 - STRLEN(backup_ext);
3593 if (wp < backup) /* empty file name ??? */
3594 wp = backup;
3595 *wp = 'z';
3596 while (*wp > 'a'
3597 && mch_stat((char *)backup, &st_new) >= 0)
3598 --*wp;
3599 /* They all exist??? Must be something wrong. */
3600 if (*wp == 'a')
3602 vim_free(backup);
3603 backup = NULL;
3607 break;
3609 vim_free(rootname);
3612 * Try to create the backup file
3614 if (backup != NULL)
3616 /* remove old backup, if present */
3617 mch_remove(backup);
3618 /* Open with O_EXCL to avoid the file being created while
3619 * we were sleeping (symlink hacker attack?) */
3620 bfd = mch_open((char *)backup,
3621 O_WRONLY|O_CREAT|O_EXTRA|O_EXCL|O_NOFOLLOW,
3622 perm & 0777);
3623 if (bfd < 0)
3625 vim_free(backup);
3626 backup = NULL;
3628 else
3630 /* set file protection same as original file, but
3631 * strip s-bit */
3632 (void)mch_setperm(backup, perm & 0777);
3634 #ifdef UNIX
3636 * Try to set the group of the backup same as the
3637 * original file. If this fails, set the protection
3638 * bits for the group same as the protection bits for
3639 * others.
3641 if (st_new.st_gid != st_old.st_gid
3642 # ifdef HAVE_FCHOWN /* sequent-ptx lacks fchown() */
3643 && fchown(bfd, (uid_t)-1, st_old.st_gid) != 0
3644 # endif
3646 mch_setperm(backup,
3647 (perm & 0707) | ((perm & 07) << 3));
3648 #endif
3651 * copy the file.
3653 write_info.bw_fd = bfd;
3654 write_info.bw_buf = copybuf;
3655 #ifdef HAS_BW_FLAGS
3656 write_info.bw_flags = FIO_NOCONVERT;
3657 #endif
3658 while ((write_info.bw_len = vim_read(fd, copybuf,
3659 BUFSIZE)) > 0)
3661 if (buf_write_bytes(&write_info) == FAIL)
3663 errmsg = (char_u *)_("E506: Can't write to backup file (add ! to override)");
3664 break;
3666 ui_breakcheck();
3667 if (got_int)
3669 errmsg = (char_u *)_(e_interr);
3670 break;
3674 if (close(bfd) < 0 && errmsg == NULL)
3675 errmsg = (char_u *)_("E507: Close error for backup file (add ! to override)");
3676 if (write_info.bw_len < 0)
3677 errmsg = (char_u *)_("E508: Can't read file for backup (add ! to override)");
3678 #ifdef UNIX
3679 set_file_time(backup, st_old.st_atime, st_old.st_mtime);
3680 #endif
3681 #ifdef HAVE_ACL
3682 mch_set_acl(backup, acl);
3683 #endif
3684 break;
3688 nobackup:
3689 close(fd); /* ignore errors for closing read file */
3690 vim_free(copybuf);
3692 if (backup == NULL && errmsg == NULL)
3693 errmsg = (char_u *)_("E509: Cannot create backup file (add ! to override)");
3694 /* ignore errors when forceit is TRUE */
3695 if ((some_error || errmsg != NULL) && !forceit)
3697 retval = FAIL;
3698 goto fail;
3700 errmsg = NULL;
3702 else
3704 char_u *dirp;
3705 char_u *p;
3706 char_u *rootname;
3709 * Make a backup by renaming the original file.
3712 * If 'cpoptions' includes the "W" flag, we don't want to
3713 * overwrite a read-only file. But rename may be possible
3714 * anyway, thus we need an extra check here.
3716 if (file_readonly && vim_strchr(p_cpo, CPO_FWRITE) != NULL)
3718 errnum = (char_u *)"E504: ";
3719 errmsg = (char_u *)_(err_readonly);
3720 goto fail;
3725 * Form the backup file name - change path/fo.o.h to
3726 * path/fo.o.h.bak Try all directories in 'backupdir', first one
3727 * that works is used.
3729 dirp = p_bdir;
3730 while (*dirp)
3733 * Isolate one directory name and make the backup file name.
3735 (void)copy_option_part(&dirp, IObuff, IOSIZE, ",");
3736 rootname = get_file_in_dir(fname, IObuff);
3737 if (rootname == NULL)
3738 backup = NULL;
3739 else
3741 backup = buf_modname(
3742 #ifdef SHORT_FNAME
3743 TRUE,
3744 #else
3745 (buf->b_p_sn || buf->b_shortname),
3746 #endif
3747 rootname, backup_ext, FALSE);
3748 vim_free(rootname);
3751 if (backup != NULL)
3754 * If we are not going to keep the backup file, don't
3755 * delete an existing one, try to use another name.
3756 * Change one character, just before the extension.
3758 if (!p_bk && mch_getperm(backup) >= 0)
3760 p = backup + STRLEN(backup) - 1 - STRLEN(backup_ext);
3761 if (p < backup) /* empty file name ??? */
3762 p = backup;
3763 *p = 'z';
3764 while (*p > 'a' && mch_getperm(backup) >= 0)
3765 --*p;
3766 /* They all exist??? Must be something wrong! */
3767 if (*p == 'a')
3769 vim_free(backup);
3770 backup = NULL;
3774 if (backup != NULL)
3777 * Delete any existing backup and move the current version
3778 * to the backup. For safety, we don't remove the backup
3779 * until the write has finished successfully. And if the
3780 * 'backup' option is set, leave it around.
3783 * If the renaming of the original file to the backup file
3784 * works, quit here.
3786 if (vim_rename(fname, backup) == 0)
3787 break;
3789 vim_free(backup); /* don't do the rename below */
3790 backup = NULL;
3793 if (backup == NULL && !forceit)
3795 errmsg = (char_u *)_("E510: Can't make backup file (add ! to override)");
3796 goto fail;
3801 #if defined(UNIX) && !defined(ARCHIE)
3802 /* When using ":w!" and the file was read-only: make it writable */
3803 if (forceit && perm >= 0 && !(perm & 0200) && st_old.st_uid == getuid()
3804 && vim_strchr(p_cpo, CPO_FWRITE) == NULL)
3806 perm |= 0200;
3807 (void)mch_setperm(fname, perm);
3808 made_writable = TRUE;
3810 #endif
3812 /* When using ":w!" and writing to the current file, 'readonly' makes no
3813 * sense, reset it, unless 'Z' appears in 'cpoptions'. */
3814 if (forceit && overwriting && vim_strchr(p_cpo, CPO_KEEPRO) == NULL)
3816 buf->b_p_ro = FALSE;
3817 #ifdef FEAT_TITLE
3818 need_maketitle = TRUE; /* set window title later */
3819 #endif
3820 #ifdef FEAT_WINDOWS
3821 status_redraw_all(); /* redraw status lines later */
3822 #endif
3825 if (end > buf->b_ml.ml_line_count)
3826 end = buf->b_ml.ml_line_count;
3827 if (buf->b_ml.ml_flags & ML_EMPTY)
3828 start = end + 1;
3831 * If the original file is being overwritten, there is a small chance that
3832 * we crash in the middle of writing. Therefore the file is preserved now.
3833 * This makes all block numbers positive so that recovery does not need
3834 * the original file.
3835 * Don't do this if there is a backup file and we are exiting.
3837 if (reset_changed && !newfile && overwriting
3838 && !(exiting && backup != NULL))
3840 ml_preserve(buf, FALSE);
3841 if (got_int)
3843 errmsg = (char_u *)_(e_interr);
3844 goto restore_backup;
3848 #ifdef MACOS_CLASSIC /* TODO: Is it need for MACOS_X? (Dany) */
3850 * Before risking to lose the original file verify if there's
3851 * a resource fork to preserve, and if cannot be done warn
3852 * the users. This happens when overwriting without backups.
3854 if (backup == NULL && overwriting && !append)
3855 if (mch_has_resource_fork(fname))
3857 errmsg = (char_u *)_("E460: The resource fork would be lost (add ! to override)");
3858 goto restore_backup;
3860 #endif
3862 #ifdef VMS
3863 vms_remove_version(fname); /* remove version */
3864 #endif
3865 /* Default: write the the file directly. May write to a temp file for
3866 * multi-byte conversion. */
3867 wfname = fname;
3869 #ifdef FEAT_MBYTE
3870 /* Check for forced 'fileencoding' from "++opt=val" argument. */
3871 if (eap != NULL && eap->force_enc != 0)
3873 fenc = eap->cmd + eap->force_enc;
3874 fenc = enc_canonize(fenc);
3875 fenc_tofree = fenc;
3877 else
3878 fenc = buf->b_p_fenc;
3881 * The file needs to be converted when 'fileencoding' is set and
3882 * 'fileencoding' differs from 'encoding'.
3884 converted = (*fenc != NUL && !same_encoding(p_enc, fenc));
3887 * Check if UTF-8 to UCS-2/4 or Latin1 conversion needs to be done. Or
3888 * Latin1 to Unicode conversion. This is handled in buf_write_bytes().
3889 * Prepare the flags for it and allocate bw_conv_buf when needed.
3891 if (converted && (enc_utf8 || STRCMP(p_enc, "latin1") == 0))
3893 wb_flags = get_fio_flags(fenc);
3894 if (wb_flags & (FIO_UCS2 | FIO_UCS4 | FIO_UTF16 | FIO_UTF8))
3896 /* Need to allocate a buffer to translate into. */
3897 if (wb_flags & (FIO_UCS2 | FIO_UTF16 | FIO_UTF8))
3898 write_info.bw_conv_buflen = bufsize * 2;
3899 else /* FIO_UCS4 */
3900 write_info.bw_conv_buflen = bufsize * 4;
3901 write_info.bw_conv_buf
3902 = lalloc((long_u)write_info.bw_conv_buflen, TRUE);
3903 if (write_info.bw_conv_buf == NULL)
3904 end = 0;
3908 # ifdef WIN3264
3909 if (converted && wb_flags == 0 && (wb_flags = get_win_fio_flags(fenc)) != 0)
3911 /* Convert UTF-8 -> UCS-2 and UCS-2 -> DBCS. Worst-case * 4: */
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;
3918 # endif
3920 # ifdef MACOS_X
3921 if (converted && wb_flags == 0 && (wb_flags = get_mac_fio_flags(fenc)) != 0)
3923 write_info.bw_conv_buflen = bufsize * 3;
3924 write_info.bw_conv_buf
3925 = lalloc((long_u)write_info.bw_conv_buflen, TRUE);
3926 if (write_info.bw_conv_buf == NULL)
3927 end = 0;
3929 # endif
3931 # if defined(FEAT_EVAL) || defined(USE_ICONV)
3932 if (converted && wb_flags == 0)
3934 # ifdef USE_ICONV
3936 * Use iconv() conversion when conversion is needed and it's not done
3937 * internally.
3939 write_info.bw_iconv_fd = (iconv_t)my_iconv_open(fenc,
3940 enc_utf8 ? (char_u *)"utf-8" : p_enc);
3941 if (write_info.bw_iconv_fd != (iconv_t)-1)
3943 /* We're going to use iconv(), allocate a buffer to convert in. */
3944 write_info.bw_conv_buflen = bufsize * ICONV_MULT;
3945 write_info.bw_conv_buf
3946 = lalloc((long_u)write_info.bw_conv_buflen, TRUE);
3947 if (write_info.bw_conv_buf == NULL)
3948 end = 0;
3949 write_info.bw_first = TRUE;
3951 # ifdef FEAT_EVAL
3952 else
3953 # endif
3954 # endif
3956 # ifdef FEAT_EVAL
3958 * When the file needs to be converted with 'charconvert' after
3959 * writing, write to a temp file instead and let the conversion
3960 * overwrite the original file.
3962 if (*p_ccv != NUL)
3964 wfname = vim_tempname('w');
3965 if (wfname == NULL) /* Can't write without a tempfile! */
3967 errmsg = (char_u *)_("E214: Can't find temp file for writing");
3968 goto restore_backup;
3971 # endif
3973 # endif
3974 if (converted && wb_flags == 0
3975 # ifdef USE_ICONV
3976 && write_info.bw_iconv_fd == (iconv_t)-1
3977 # endif
3978 # ifdef FEAT_EVAL
3979 && wfname == fname
3980 # endif
3983 if (!forceit)
3985 errmsg = (char_u *)_("E213: Cannot convert (add ! to write without conversion)");
3986 goto restore_backup;
3988 notconverted = TRUE;
3990 #endif
3993 * Open the file "wfname" for writing.
3994 * We may try to open the file twice: If we can't write to the
3995 * file and forceit is TRUE we delete the existing file and try to create
3996 * a new one. If this still fails we may have lost the original file!
3997 * (this may happen when the user reached his quotum for number of files).
3998 * Appending will fail if the file does not exist and forceit is FALSE.
4000 while ((fd = mch_open((char *)wfname, O_WRONLY | O_EXTRA | (append
4001 ? (forceit ? (O_APPEND | O_CREAT) : O_APPEND)
4002 : (O_CREAT | O_TRUNC))
4003 , perm < 0 ? 0666 : (perm & 0777))) < 0)
4006 * A forced write will try to create a new file if the old one is
4007 * still readonly. This may also happen when the directory is
4008 * read-only. In that case the mch_remove() will fail.
4010 if (errmsg == NULL)
4012 #ifdef UNIX
4013 struct stat st;
4015 /* Don't delete the file when it's a hard or symbolic link. */
4016 if ((!newfile && st_old.st_nlink > 1)
4017 || (mch_lstat((char *)fname, &st) == 0
4018 && (st.st_dev != st_old.st_dev
4019 || st.st_ino != st_old.st_ino)))
4020 errmsg = (char_u *)_("E166: Can't open linked file for writing");
4021 else
4022 #endif
4024 errmsg = (char_u *)_("E212: Can't open file for writing");
4025 if (forceit && vim_strchr(p_cpo, CPO_FWRITE) == NULL
4026 && perm >= 0)
4028 #ifdef UNIX
4029 /* we write to the file, thus it should be marked
4030 writable after all */
4031 if (!(perm & 0200))
4032 made_writable = TRUE;
4033 perm |= 0200;
4034 if (st_old.st_uid != getuid() || st_old.st_gid != getgid())
4035 perm &= 0777;
4036 #endif
4037 if (!append) /* don't remove when appending */
4038 mch_remove(wfname);
4039 continue;
4044 restore_backup:
4046 struct stat st;
4049 * If we failed to open the file, we don't need a backup. Throw it
4050 * away. If we moved or removed the original file try to put the
4051 * backup in its place.
4053 if (backup != NULL && wfname == fname)
4055 if (backup_copy)
4058 * There is a small chance that we removed the original,
4059 * try to move the copy in its place.
4060 * This may not work if the vim_rename() fails.
4061 * In that case we leave the copy around.
4063 /* If file does not exist, put the copy in its place */
4064 if (mch_stat((char *)fname, &st) < 0)
4065 vim_rename(backup, fname);
4066 /* if original file does exist throw away the copy */
4067 if (mch_stat((char *)fname, &st) >= 0)
4068 mch_remove(backup);
4070 else
4072 /* try to put the original file back */
4073 vim_rename(backup, fname);
4077 /* if original file no longer exists give an extra warning */
4078 if (!newfile && mch_stat((char *)fname, &st) < 0)
4079 end = 0;
4082 #ifdef FEAT_MBYTE
4083 if (wfname != fname)
4084 vim_free(wfname);
4085 #endif
4086 goto fail;
4088 errmsg = NULL;
4090 #if defined(MACOS_CLASSIC) || defined(WIN3264)
4091 /* TODO: Is it need for MACOS_X? (Dany) */
4093 * On macintosh copy the original files attributes (i.e. the backup)
4094 * This is done in order to preserve the resource fork and the
4095 * Finder attribute (label, comments, custom icons, file creator)
4097 if (backup != NULL && overwriting && !append)
4099 if (backup_copy)
4100 (void)mch_copy_file_attribute(wfname, backup);
4101 else
4102 (void)mch_copy_file_attribute(backup, wfname);
4105 if (!overwriting && !append)
4107 if (buf->b_ffname != NULL)
4108 (void)mch_copy_file_attribute(buf->b_ffname, wfname);
4109 /* Should copy resource fork */
4111 #endif
4113 write_info.bw_fd = fd;
4115 #ifdef FEAT_CRYPT
4116 if (*buf->b_p_key && !filtering)
4118 crypt_init_keys(buf->b_p_key);
4119 /* Write magic number, so that Vim knows that this file is encrypted
4120 * when reading it again. This also undergoes utf-8 to ucs-2/4
4121 * conversion when needed. */
4122 write_info.bw_buf = (char_u *)CRYPT_MAGIC;
4123 write_info.bw_len = CRYPT_MAGIC_LEN;
4124 write_info.bw_flags = FIO_NOCONVERT;
4125 if (buf_write_bytes(&write_info) == FAIL)
4126 end = 0;
4127 wb_flags |= FIO_ENCRYPTED;
4129 #endif
4131 write_info.bw_buf = buffer;
4132 nchars = 0;
4134 /* use "++bin", "++nobin" or 'binary' */
4135 if (eap != NULL && eap->force_bin != 0)
4136 write_bin = (eap->force_bin == FORCE_BIN);
4137 else
4138 write_bin = buf->b_p_bin;
4140 #ifdef FEAT_MBYTE
4142 * The BOM is written just after the encryption magic number.
4143 * Skip it when appending and the file already existed, the BOM only makes
4144 * sense at the start of the file.
4146 if (buf->b_p_bomb && !write_bin && (!append || perm < 0))
4148 write_info.bw_len = make_bom(buffer, fenc);
4149 if (write_info.bw_len > 0)
4151 /* don't convert, do encryption */
4152 write_info.bw_flags = FIO_NOCONVERT | wb_flags;
4153 if (buf_write_bytes(&write_info) == FAIL)
4154 end = 0;
4155 else
4156 nchars += write_info.bw_len;
4159 #endif
4161 write_info.bw_len = bufsize;
4162 #ifdef HAS_BW_FLAGS
4163 write_info.bw_flags = wb_flags;
4164 #endif
4165 fileformat = get_fileformat_force(buf, eap);
4166 s = buffer;
4167 len = 0;
4168 for (lnum = start; lnum <= end; ++lnum)
4171 * The next while loop is done once for each character written.
4172 * Keep it fast!
4174 ptr = ml_get_buf(buf, lnum, FALSE) - 1;
4175 while ((c = *++ptr) != NUL)
4177 if (c == NL)
4178 *s = NUL; /* replace newlines with NULs */
4179 else if (c == CAR && fileformat == EOL_MAC)
4180 *s = NL; /* Mac: replace CRs with NLs */
4181 else
4182 *s = c;
4183 ++s;
4184 if (++len != bufsize)
4185 continue;
4186 if (buf_write_bytes(&write_info) == FAIL)
4188 end = 0; /* write error: break loop */
4189 break;
4191 nchars += bufsize;
4192 s = buffer;
4193 len = 0;
4195 /* write failed or last line has no EOL: stop here */
4196 if (end == 0
4197 || (lnum == end
4198 && write_bin
4199 && (lnum == write_no_eol_lnum
4200 || (lnum == buf->b_ml.ml_line_count && !buf->b_p_eol))))
4202 ++lnum; /* written the line, count it */
4203 no_eol = TRUE;
4204 break;
4206 if (fileformat == EOL_UNIX)
4207 *s++ = NL;
4208 else
4210 *s++ = CAR; /* EOL_MAC or EOL_DOS: write CR */
4211 if (fileformat == EOL_DOS) /* write CR-NL */
4213 if (++len == bufsize)
4215 if (buf_write_bytes(&write_info) == FAIL)
4217 end = 0; /* write error: break loop */
4218 break;
4220 nchars += bufsize;
4221 s = buffer;
4222 len = 0;
4224 *s++ = NL;
4227 if (++len == bufsize && end)
4229 if (buf_write_bytes(&write_info) == FAIL)
4231 end = 0; /* write error: break loop */
4232 break;
4234 nchars += bufsize;
4235 s = buffer;
4236 len = 0;
4238 ui_breakcheck();
4239 if (got_int)
4241 end = 0; /* Interrupted, break loop */
4242 break;
4245 #ifdef VMS
4247 * On VMS there is a problem: newlines get added when writing blocks
4248 * at a time. Fix it by writing a line at a time.
4249 * This is much slower!
4250 * Explanation: VAX/DECC RTL insists that records in some RMS
4251 * structures end with a newline (carriage return) character, and if
4252 * they don't it adds one.
4253 * With other RMS structures it works perfect without this fix.
4255 if (buf->b_fab_rfm == FAB$C_VFC
4256 || ((buf->b_fab_rat & (FAB$M_FTN | FAB$M_CR)) != 0))
4258 int b2write;
4260 buf->b_fab_mrs = (buf->b_fab_mrs == 0
4261 ? MIN(4096, bufsize)
4262 : MIN(buf->b_fab_mrs, bufsize));
4264 b2write = len;
4265 while (b2write > 0)
4267 write_info.bw_len = MIN(b2write, buf->b_fab_mrs);
4268 if (buf_write_bytes(&write_info) == FAIL)
4270 end = 0;
4271 break;
4273 b2write -= MIN(b2write, buf->b_fab_mrs);
4275 write_info.bw_len = bufsize;
4276 nchars += len;
4277 s = buffer;
4278 len = 0;
4280 #endif
4282 if (len > 0 && end > 0)
4284 write_info.bw_len = len;
4285 if (buf_write_bytes(&write_info) == FAIL)
4286 end = 0; /* write error */
4287 nchars += len;
4290 #if defined(UNIX) && defined(HAVE_FSYNC)
4291 /* On many journalling file systems there is a bug that causes both the
4292 * original and the backup file to be lost when halting the system right
4293 * after writing the file. That's because only the meta-data is
4294 * journalled. Syncing the file slows down the system, but assures it has
4295 * been written to disk and we don't lose it.
4296 * For a device do try the fsync() but don't complain if it does not work
4297 * (could be a pipe).
4298 * If the 'fsync' option is FALSE, don't fsync(). Useful for laptops. */
4299 if (p_fs && fsync(fd) != 0 && !device)
4301 errmsg = (char_u *)_("E667: Fsync failed");
4302 end = 0;
4304 #endif
4306 #ifdef UNIX
4307 /* When creating a new file, set its owner/group to that of the original
4308 * file. Get the new device and inode number. */
4309 if (backup != NULL && !backup_copy)
4311 # ifdef HAVE_FCHOWN
4312 struct stat st;
4314 /* don't change the owner when it's already OK, some systems remove
4315 * permission or ACL stuff */
4316 if (mch_stat((char *)wfname, &st) < 0
4317 || st.st_uid != st_old.st_uid
4318 || st.st_gid != st_old.st_gid)
4320 fchown(fd, st_old.st_uid, st_old.st_gid);
4321 if (perm >= 0) /* set permission again, may have changed */
4322 (void)mch_setperm(wfname, perm);
4324 # endif
4325 buf_setino(buf);
4327 else if (buf->b_dev < 0)
4328 /* Set the inode when creating a new file. */
4329 buf_setino(buf);
4330 #endif
4332 if (close(fd) != 0)
4334 errmsg = (char_u *)_("E512: Close failed");
4335 end = 0;
4338 #ifdef UNIX
4339 if (made_writable)
4340 perm &= ~0200; /* reset 'w' bit for security reasons */
4341 #endif
4342 if (perm >= 0) /* set perm. of new file same as old file */
4343 (void)mch_setperm(wfname, perm);
4344 #ifdef RISCOS
4345 if (!append && !filtering)
4346 /* Set the filetype after writing the file. */
4347 mch_set_filetype(wfname, buf->b_p_oft);
4348 #endif
4349 #ifdef HAVE_ACL
4350 /* Probably need to set the ACL before changing the user (can't set the
4351 * ACL on a file the user doesn't own). */
4352 if (!backup_copy)
4353 mch_set_acl(wfname, acl);
4354 #endif
4357 #if defined(FEAT_MBYTE) && defined(FEAT_EVAL)
4358 if (wfname != fname)
4361 * The file was written to a temp file, now it needs to be converted
4362 * with 'charconvert' to (overwrite) the output file.
4364 if (end != 0)
4366 if (eval_charconvert(enc_utf8 ? (char_u *)"utf-8" : p_enc, fenc,
4367 wfname, fname) == FAIL)
4369 write_info.bw_conv_error = TRUE;
4370 end = 0;
4373 mch_remove(wfname);
4374 vim_free(wfname);
4376 #endif
4378 if (end == 0)
4380 if (errmsg == NULL)
4382 #ifdef FEAT_MBYTE
4383 if (write_info.bw_conv_error)
4384 errmsg = (char_u *)_("E513: write error, conversion failed (make 'fenc' empty to override)");
4385 else
4386 #endif
4387 if (got_int)
4388 errmsg = (char_u *)_(e_interr);
4389 else
4390 errmsg = (char_u *)_("E514: write error (file system full?)");
4394 * If we have a backup file, try to put it in place of the new file,
4395 * because the new file is probably corrupt. This avoids loosing the
4396 * original file when trying to make a backup when writing the file a
4397 * second time.
4398 * When "backup_copy" is set we need to copy the backup over the new
4399 * file. Otherwise rename the backup file.
4400 * If this is OK, don't give the extra warning message.
4402 if (backup != NULL)
4404 if (backup_copy)
4406 /* This may take a while, if we were interrupted let the user
4407 * know we got the message. */
4408 if (got_int)
4410 MSG(_(e_interr));
4411 out_flush();
4413 if ((fd = mch_open((char *)backup, O_RDONLY | O_EXTRA, 0)) >= 0)
4415 if ((write_info.bw_fd = mch_open((char *)fname,
4416 O_WRONLY | O_CREAT | O_TRUNC | O_EXTRA,
4417 perm & 0777)) >= 0)
4419 /* copy the file. */
4420 write_info.bw_buf = smallbuf;
4421 #ifdef HAS_BW_FLAGS
4422 write_info.bw_flags = FIO_NOCONVERT;
4423 #endif
4424 while ((write_info.bw_len = vim_read(fd, smallbuf,
4425 SMBUFSIZE)) > 0)
4426 if (buf_write_bytes(&write_info) == FAIL)
4427 break;
4429 if (close(write_info.bw_fd) >= 0
4430 && write_info.bw_len == 0)
4431 end = 1; /* success */
4433 close(fd); /* ignore errors for closing read file */
4436 else
4438 if (vim_rename(backup, fname) == 0)
4439 end = 1;
4442 goto fail;
4445 lnum -= start; /* compute number of written lines */
4446 --no_wait_return; /* may wait for return now */
4448 #if !(defined(UNIX) || defined(VMS))
4449 fname = sfname; /* use shortname now, for the messages */
4450 #endif
4451 if (!filtering)
4453 msg_add_fname(buf, fname); /* put fname in IObuff with quotes */
4454 c = FALSE;
4455 #ifdef FEAT_MBYTE
4456 if (write_info.bw_conv_error)
4458 STRCAT(IObuff, _(" CONVERSION ERROR"));
4459 c = TRUE;
4461 else if (notconverted)
4463 STRCAT(IObuff, _("[NOT converted]"));
4464 c = TRUE;
4466 else if (converted)
4468 STRCAT(IObuff, _("[converted]"));
4469 c = TRUE;
4471 #endif
4472 if (device)
4474 STRCAT(IObuff, _("[Device]"));
4475 c = TRUE;
4477 else if (newfile)
4479 STRCAT(IObuff, shortmess(SHM_NEW) ? _("[New]") : _("[New File]"));
4480 c = TRUE;
4482 if (no_eol)
4484 msg_add_eol();
4485 c = TRUE;
4487 /* may add [unix/dos/mac] */
4488 if (msg_add_fileformat(fileformat))
4489 c = TRUE;
4490 #ifdef FEAT_CRYPT
4491 if (wb_flags & FIO_ENCRYPTED)
4493 STRCAT(IObuff, _("[crypted]"));
4494 c = TRUE;
4496 #endif
4497 msg_add_lines(c, (long)lnum, nchars); /* add line/char count */
4498 if (!shortmess(SHM_WRITE))
4500 if (append)
4501 STRCAT(IObuff, shortmess(SHM_WRI) ? _(" [a]") : _(" appended"));
4502 else
4503 STRCAT(IObuff, shortmess(SHM_WRI) ? _(" [w]") : _(" written"));
4506 set_keep_msg(msg_trunc_attr(IObuff, FALSE, 0), 0);
4509 /* When written everything correctly: reset 'modified'. Unless not
4510 * writing to the original file and '+' is not in 'cpoptions'. */
4511 if (reset_changed && whole && !append
4512 #ifdef FEAT_MBYTE
4513 && !write_info.bw_conv_error
4514 #endif
4515 && (overwriting || vim_strchr(p_cpo, CPO_PLUS) != NULL)
4518 unchanged(buf, TRUE);
4519 u_unchanged(buf);
4523 * If written to the current file, update the timestamp of the swap file
4524 * and reset the BF_WRITE_MASK flags. Also sets buf->b_mtime.
4526 if (overwriting)
4528 ml_timestamp(buf);
4529 if (append)
4530 buf->b_flags &= ~BF_NEW;
4531 else
4532 buf->b_flags &= ~BF_WRITE_MASK;
4536 * If we kept a backup until now, and we are in patch mode, then we make
4537 * the backup file our 'original' file.
4539 if (*p_pm && dobackup)
4541 char *org = (char *)buf_modname(
4542 #ifdef SHORT_FNAME
4543 TRUE,
4544 #else
4545 (buf->b_p_sn || buf->b_shortname),
4546 #endif
4547 fname, p_pm, FALSE);
4549 if (backup != NULL)
4551 struct stat st;
4554 * If the original file does not exist yet
4555 * the current backup file becomes the original file
4557 if (org == NULL)
4558 EMSG(_("E205: Patchmode: can't save original file"));
4559 else if (mch_stat(org, &st) < 0)
4561 vim_rename(backup, (char_u *)org);
4562 vim_free(backup); /* don't delete the file */
4563 backup = NULL;
4564 #ifdef UNIX
4565 set_file_time((char_u *)org, st_old.st_atime, st_old.st_mtime);
4566 #endif
4570 * If there is no backup file, remember that a (new) file was
4571 * created.
4573 else
4575 int empty_fd;
4577 if (org == NULL
4578 || (empty_fd = mch_open(org,
4579 O_CREAT | O_EXTRA | O_EXCL | O_NOFOLLOW,
4580 perm < 0 ? 0666 : (perm & 0777))) < 0)
4581 EMSG(_("E206: patchmode: can't touch empty original file"));
4582 else
4583 close(empty_fd);
4585 if (org != NULL)
4587 mch_setperm((char_u *)org, mch_getperm(fname) & 0777);
4588 vim_free(org);
4593 * Remove the backup unless 'backup' option is set
4595 if (!p_bk && backup != NULL && mch_remove(backup) != 0)
4596 EMSG(_("E207: Can't delete backup file"));
4598 #ifdef FEAT_SUN_WORKSHOP
4599 if (usingSunWorkShop)
4600 workshop_file_saved((char *) ffname);
4601 #endif
4603 goto nofail;
4606 * Finish up. We get here either after failure or success.
4608 fail:
4609 --no_wait_return; /* may wait for return now */
4610 nofail:
4612 /* Done saving, we accept changed buffer warnings again */
4613 buf->b_saving = FALSE;
4615 vim_free(backup);
4616 if (buffer != smallbuf)
4617 vim_free(buffer);
4618 #ifdef FEAT_MBYTE
4619 vim_free(fenc_tofree);
4620 vim_free(write_info.bw_conv_buf);
4621 # ifdef USE_ICONV
4622 if (write_info.bw_iconv_fd != (iconv_t)-1)
4624 iconv_close(write_info.bw_iconv_fd);
4625 write_info.bw_iconv_fd = (iconv_t)-1;
4627 # endif
4628 #endif
4629 #ifdef HAVE_ACL
4630 mch_free_acl(acl);
4631 #endif
4633 if (errmsg != NULL)
4635 int numlen = errnum != NULL ? (int)STRLEN(errnum) : 0;
4637 attr = hl_attr(HLF_E); /* set highlight for error messages */
4638 msg_add_fname(buf,
4639 #ifndef UNIX
4640 sfname
4641 #else
4642 fname
4643 #endif
4644 ); /* put file name in IObuff with quotes */
4645 if (STRLEN(IObuff) + STRLEN(errmsg) + numlen >= IOSIZE)
4646 IObuff[IOSIZE - STRLEN(errmsg) - numlen - 1] = NUL;
4647 /* If the error message has the form "is ...", put the error number in
4648 * front of the file name. */
4649 if (errnum != NULL)
4651 mch_memmove(IObuff + numlen, IObuff, STRLEN(IObuff) + 1);
4652 mch_memmove(IObuff, errnum, (size_t)numlen);
4654 STRCAT(IObuff, errmsg);
4655 emsg(IObuff);
4657 retval = FAIL;
4658 if (end == 0)
4660 MSG_PUTS_ATTR(_("\nWARNING: Original file may be lost or damaged\n"),
4661 attr | MSG_HIST);
4662 MSG_PUTS_ATTR(_("don't quit the editor until the file is successfully written!"),
4663 attr | MSG_HIST);
4665 /* Update the timestamp to avoid an "overwrite changed file"
4666 * prompt when writing again. */
4667 if (mch_stat((char *)fname, &st_old) >= 0)
4669 buf_store_time(buf, &st_old, fname);
4670 buf->b_mtime_read = buf->b_mtime;
4674 msg_scroll = msg_save;
4676 #ifdef FEAT_AUTOCMD
4677 #ifdef FEAT_EVAL
4678 if (!should_abort(retval))
4679 #else
4680 if (!got_int)
4681 #endif
4683 aco_save_T aco;
4685 write_no_eol_lnum = 0; /* in case it was set by the previous read */
4688 * Apply POST autocommands.
4689 * Careful: The autocommands may call buf_write() recursively!
4691 aucmd_prepbuf(&aco, buf);
4693 if (append)
4694 apply_autocmds_exarg(EVENT_FILEAPPENDPOST, fname, fname,
4695 FALSE, curbuf, eap);
4696 else if (filtering)
4697 apply_autocmds_exarg(EVENT_FILTERWRITEPOST, NULL, fname,
4698 FALSE, curbuf, eap);
4699 else if (reset_changed && whole)
4700 apply_autocmds_exarg(EVENT_BUFWRITEPOST, fname, fname,
4701 FALSE, curbuf, eap);
4702 else
4703 apply_autocmds_exarg(EVENT_FILEWRITEPOST, fname, fname,
4704 FALSE, curbuf, eap);
4706 /* restore curwin/curbuf and a few other things */
4707 aucmd_restbuf(&aco);
4709 #ifdef FEAT_EVAL
4710 if (aborting()) /* autocmds may abort script processing */
4711 retval = FALSE;
4712 #endif
4714 #endif
4716 got_int |= prev_got_int;
4718 #ifdef MACOS_CLASSIC /* TODO: Is it need for MACOS_X? (Dany) */
4719 /* Update machine specific information. */
4720 mch_post_buffer_write(buf);
4721 #endif
4722 return retval;
4726 * Set the name of the current buffer. Use when the buffer doesn't have a
4727 * name and a ":r" or ":w" command with a file name is used.
4729 static int
4730 set_rw_fname(fname, sfname)
4731 char_u *fname;
4732 char_u *sfname;
4734 #ifdef FEAT_AUTOCMD
4735 /* It's like the unnamed buffer is deleted.... */
4736 if (curbuf->b_p_bl)
4737 apply_autocmds(EVENT_BUFDELETE, NULL, NULL, FALSE, curbuf);
4738 apply_autocmds(EVENT_BUFWIPEOUT, NULL, NULL, FALSE, curbuf);
4739 # ifdef FEAT_EVAL
4740 if (aborting()) /* autocmds may abort script processing */
4741 return FAIL;
4742 # endif
4743 #endif
4745 if (setfname(curbuf, fname, sfname, FALSE) == OK)
4746 curbuf->b_flags |= BF_NOTEDITED;
4748 #ifdef FEAT_AUTOCMD
4749 /* ....and a new named one is created */
4750 apply_autocmds(EVENT_BUFNEW, NULL, NULL, FALSE, curbuf);
4751 if (curbuf->b_p_bl)
4752 apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, curbuf);
4753 # ifdef FEAT_EVAL
4754 if (aborting()) /* autocmds may abort script processing */
4755 return FAIL;
4756 # endif
4758 /* Do filetype detection now if 'filetype' is empty. */
4759 if (*curbuf->b_p_ft == NUL)
4761 if (au_has_group((char_u *)"filetypedetect"))
4762 (void)do_doautocmd((char_u *)"filetypedetect BufRead", FALSE);
4763 do_modelines(0);
4765 #endif
4767 return OK;
4771 * Put file name into IObuff with quotes.
4773 void
4774 msg_add_fname(buf, fname)
4775 buf_T *buf;
4776 char_u *fname;
4778 if (fname == NULL)
4779 fname = (char_u *)"-stdin-";
4780 home_replace(buf, fname, IObuff + 1, IOSIZE - 4, TRUE);
4781 IObuff[0] = '"';
4782 STRCAT(IObuff, "\" ");
4786 * Append message for text mode to IObuff.
4787 * Return TRUE if something appended.
4789 static int
4790 msg_add_fileformat(eol_type)
4791 int eol_type;
4793 #ifndef USE_CRNL
4794 if (eol_type == EOL_DOS)
4796 STRCAT(IObuff, shortmess(SHM_TEXT) ? _("[dos]") : _("[dos format]"));
4797 return TRUE;
4799 #endif
4800 #ifndef USE_CR
4801 if (eol_type == EOL_MAC)
4803 STRCAT(IObuff, shortmess(SHM_TEXT) ? _("[mac]") : _("[mac format]"));
4804 return TRUE;
4806 #endif
4807 #if defined(USE_CRNL) || defined(USE_CR)
4808 if (eol_type == EOL_UNIX)
4810 STRCAT(IObuff, shortmess(SHM_TEXT) ? _("[unix]") : _("[unix format]"));
4811 return TRUE;
4813 #endif
4814 return FALSE;
4818 * Append line and character count to IObuff.
4820 void
4821 msg_add_lines(insert_space, lnum, nchars)
4822 int insert_space;
4823 long lnum;
4824 long nchars;
4826 char_u *p;
4828 p = IObuff + STRLEN(IObuff);
4830 if (insert_space)
4831 *p++ = ' ';
4832 if (shortmess(SHM_LINES))
4833 sprintf((char *)p, "%ldL, %ldC", lnum, nchars);
4834 else
4836 if (lnum == 1)
4837 STRCPY(p, _("1 line, "));
4838 else
4839 sprintf((char *)p, _("%ld lines, "), lnum);
4840 p += STRLEN(p);
4841 if (nchars == 1)
4842 STRCPY(p, _("1 character"));
4843 else
4844 sprintf((char *)p, _("%ld characters"), nchars);
4849 * Append message for missing line separator to IObuff.
4851 static void
4852 msg_add_eol()
4854 STRCAT(IObuff, shortmess(SHM_LAST) ? _("[noeol]") : _("[Incomplete last line]"));
4858 * Check modification time of file, before writing to it.
4859 * The size isn't checked, because using a tool like "gzip" takes care of
4860 * using the same timestamp but can't set the size.
4862 static int
4863 check_mtime(buf, st)
4864 buf_T *buf;
4865 struct stat *st;
4867 if (buf->b_mtime_read != 0
4868 && time_differs((long)st->st_mtime, buf->b_mtime_read))
4870 msg_scroll = TRUE; /* don't overwrite messages here */
4871 msg_silent = 0; /* must give this prompt */
4872 /* don't use emsg() here, don't want to flush the buffers */
4873 MSG_ATTR(_("WARNING: The file has been changed since reading it!!!"),
4874 hl_attr(HLF_E));
4875 if (ask_yesno((char_u *)_("Do you really want to write to it"),
4876 TRUE) == 'n')
4877 return FAIL;
4878 msg_scroll = FALSE; /* always overwrite the file message now */
4880 return OK;
4883 static int
4884 time_differs(t1, t2)
4885 long t1, t2;
4887 #if defined(__linux__) || defined(MSDOS) || defined(MSWIN)
4888 /* On a FAT filesystem, esp. under Linux, there are only 5 bits to store
4889 * the seconds. Since the roundoff is done when flushing the inode, the
4890 * time may change unexpectedly by one second!!! */
4891 return (t1 - t2 > 1 || t2 - t1 > 1);
4892 #else
4893 return (t1 != t2);
4894 #endif
4898 * Call write() to write a number of bytes to the file.
4899 * Also handles encryption and 'encoding' conversion.
4901 * Return FAIL for failure, OK otherwise.
4903 static int
4904 buf_write_bytes(ip)
4905 struct bw_info *ip;
4907 int wlen;
4908 char_u *buf = ip->bw_buf; /* data to write */
4909 int len = ip->bw_len; /* length of data */
4910 #ifdef HAS_BW_FLAGS
4911 int flags = ip->bw_flags; /* extra flags */
4912 #endif
4914 #ifdef FEAT_MBYTE
4916 * Skip conversion when writing the crypt magic number or the BOM.
4918 if (!(flags & FIO_NOCONVERT))
4920 char_u *p;
4921 unsigned c;
4922 int n;
4924 if (flags & FIO_UTF8)
4927 * Convert latin1 in the buffer to UTF-8 in the file.
4929 p = ip->bw_conv_buf; /* translate to buffer */
4930 for (wlen = 0; wlen < len; ++wlen)
4931 p += utf_char2bytes(buf[wlen], p);
4932 buf = ip->bw_conv_buf;
4933 len = (int)(p - ip->bw_conv_buf);
4935 else if (flags & (FIO_UCS4 | FIO_UTF16 | FIO_UCS2 | FIO_LATIN1))
4938 * Convert UTF-8 bytes in the buffer to UCS-2, UCS-4, UTF-16 or
4939 * Latin1 chars in the file.
4941 if (flags & FIO_LATIN1)
4942 p = buf; /* translate in-place (can only get shorter) */
4943 else
4944 p = ip->bw_conv_buf; /* translate to buffer */
4945 for (wlen = 0; wlen < len; wlen += n)
4947 if (wlen == 0 && ip->bw_restlen != 0)
4949 int l;
4951 /* Use remainder of previous call. Append the start of
4952 * buf[] to get a full sequence. Might still be too
4953 * short! */
4954 l = CONV_RESTLEN - ip->bw_restlen;
4955 if (l > len)
4956 l = len;
4957 mch_memmove(ip->bw_rest + ip->bw_restlen, buf, (size_t)l);
4958 n = utf_ptr2len_len(ip->bw_rest, ip->bw_restlen + l);
4959 if (n > ip->bw_restlen + len)
4961 /* We have an incomplete byte sequence at the end to
4962 * be written. We can't convert it without the
4963 * remaining bytes. Keep them for the next call. */
4964 if (ip->bw_restlen + len > CONV_RESTLEN)
4965 return FAIL;
4966 ip->bw_restlen += len;
4967 break;
4969 if (n > 1)
4970 c = utf_ptr2char(ip->bw_rest);
4971 else
4972 c = ip->bw_rest[0];
4973 if (n >= ip->bw_restlen)
4975 n -= ip->bw_restlen;
4976 ip->bw_restlen = 0;
4978 else
4980 ip->bw_restlen -= n;
4981 mch_memmove(ip->bw_rest, ip->bw_rest + n,
4982 (size_t)ip->bw_restlen);
4983 n = 0;
4986 else
4988 n = utf_ptr2len_len(buf + wlen, len - wlen);
4989 if (n > len - wlen)
4991 /* We have an incomplete byte sequence at the end to
4992 * be written. We can't convert it without the
4993 * remaining bytes. Keep them for the next call. */
4994 if (len - wlen > CONV_RESTLEN)
4995 return FAIL;
4996 ip->bw_restlen = len - wlen;
4997 mch_memmove(ip->bw_rest, buf + wlen,
4998 (size_t)ip->bw_restlen);
4999 break;
5001 if (n > 1)
5002 c = utf_ptr2char(buf + wlen);
5003 else
5004 c = buf[wlen];
5007 ip->bw_conv_error |= ucs2bytes(c, &p, flags);
5009 if (flags & FIO_LATIN1)
5010 len = (int)(p - buf);
5011 else
5013 buf = ip->bw_conv_buf;
5014 len = (int)(p - ip->bw_conv_buf);
5018 # ifdef WIN3264
5019 else if (flags & FIO_CODEPAGE)
5022 * Convert UTF-8 or codepage to UCS-2 and then to MS-Windows
5023 * codepage.
5025 char_u *from;
5026 size_t fromlen;
5027 char_u *to;
5028 int u8c;
5029 BOOL bad = FALSE;
5030 int needed;
5032 if (ip->bw_restlen > 0)
5034 /* Need to concatenate the remainder of the previous call and
5035 * the bytes of the current call. Use the end of the
5036 * conversion buffer for this. */
5037 fromlen = len + ip->bw_restlen;
5038 from = ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
5039 mch_memmove(from, ip->bw_rest, (size_t)ip->bw_restlen);
5040 mch_memmove(from + ip->bw_restlen, buf, (size_t)len);
5042 else
5044 from = buf;
5045 fromlen = len;
5048 to = ip->bw_conv_buf;
5049 if (enc_utf8)
5051 /* Convert from UTF-8 to UCS-2, to the start of the buffer.
5052 * The buffer has been allocated to be big enough. */
5053 while (fromlen > 0)
5055 n = (int)utf_ptr2len_len(from, (int)fromlen);
5056 if (n > (int)fromlen) /* incomplete byte sequence */
5057 break;
5058 u8c = utf_ptr2char(from);
5059 *to++ = (u8c & 0xff);
5060 *to++ = (u8c >> 8);
5061 fromlen -= n;
5062 from += n;
5065 /* Copy remainder to ip->bw_rest[] to be used for the next
5066 * call. */
5067 if (fromlen > CONV_RESTLEN)
5069 /* weird overlong sequence */
5070 ip->bw_conv_error = TRUE;
5071 return FAIL;
5073 mch_memmove(ip->bw_rest, from, fromlen);
5074 ip->bw_restlen = (int)fromlen;
5076 else
5078 /* Convert from enc_codepage to UCS-2, to the start of the
5079 * buffer. The buffer has been allocated to be big enough. */
5080 ip->bw_restlen = 0;
5081 needed = MultiByteToWideChar(enc_codepage,
5082 MB_ERR_INVALID_CHARS, (LPCSTR)from, (int)fromlen,
5083 NULL, 0);
5084 if (needed == 0)
5086 /* When conversion fails there may be a trailing byte. */
5087 needed = MultiByteToWideChar(enc_codepage,
5088 MB_ERR_INVALID_CHARS, (LPCSTR)from, (int)fromlen - 1,
5089 NULL, 0);
5090 if (needed == 0)
5092 /* Conversion doesn't work. */
5093 ip->bw_conv_error = TRUE;
5094 return FAIL;
5096 /* Save the trailing byte for the next call. */
5097 ip->bw_rest[0] = from[fromlen - 1];
5098 ip->bw_restlen = 1;
5100 needed = MultiByteToWideChar(enc_codepage, MB_ERR_INVALID_CHARS,
5101 (LPCSTR)from, (int)(fromlen - ip->bw_restlen),
5102 (LPWSTR)to, needed);
5103 if (needed == 0)
5105 /* Safety check: Conversion doesn't work. */
5106 ip->bw_conv_error = TRUE;
5107 return FAIL;
5109 to += needed * 2;
5112 fromlen = to - ip->bw_conv_buf;
5113 buf = to;
5114 # ifdef CP_UTF8 /* VC 4.1 doesn't define CP_UTF8 */
5115 if (FIO_GET_CP(flags) == CP_UTF8)
5117 /* Convert from UCS-2 to UTF-8, using the remainder of the
5118 * conversion buffer. Fails when out of space. */
5119 for (from = ip->bw_conv_buf; fromlen > 1; fromlen -= 2)
5121 u8c = *from++;
5122 u8c += (*from++ << 8);
5123 to += utf_char2bytes(u8c, to);
5124 if (to + 6 >= ip->bw_conv_buf + ip->bw_conv_buflen)
5126 ip->bw_conv_error = TRUE;
5127 return FAIL;
5130 len = (int)(to - buf);
5132 else
5133 #endif
5135 /* Convert from UCS-2 to the codepage, using the remainder of
5136 * the conversion buffer. If the conversion uses the default
5137 * character "0", the data doesn't fit in this encoding, so
5138 * fail. */
5139 len = WideCharToMultiByte(FIO_GET_CP(flags), 0,
5140 (LPCWSTR)ip->bw_conv_buf, (int)fromlen / sizeof(WCHAR),
5141 (LPSTR)to, (int)(ip->bw_conv_buflen - fromlen), 0,
5142 &bad);
5143 if (bad)
5145 ip->bw_conv_error = TRUE;
5146 return FAIL;
5150 # endif
5152 # ifdef MACOS_CONVERT
5153 else if (flags & FIO_MACROMAN)
5156 * Convert UTF-8 or latin1 to Apple MacRoman.
5158 char_u *from;
5159 size_t fromlen;
5161 if (ip->bw_restlen > 0)
5163 /* Need to concatenate the remainder of the previous call and
5164 * the bytes of the current call. Use the end of the
5165 * conversion buffer for this. */
5166 fromlen = len + ip->bw_restlen;
5167 from = ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
5168 mch_memmove(from, ip->bw_rest, (size_t)ip->bw_restlen);
5169 mch_memmove(from + ip->bw_restlen, buf, (size_t)len);
5171 else
5173 from = buf;
5174 fromlen = len;
5177 if (enc2macroman(from, fromlen,
5178 ip->bw_conv_buf, &len, ip->bw_conv_buflen,
5179 ip->bw_rest, &ip->bw_restlen) == FAIL)
5181 ip->bw_conv_error = TRUE;
5182 return FAIL;
5184 buf = ip->bw_conv_buf;
5186 # endif
5188 # ifdef USE_ICONV
5189 if (ip->bw_iconv_fd != (iconv_t)-1)
5191 const char *from;
5192 size_t fromlen;
5193 char *to;
5194 size_t tolen;
5196 /* Convert with iconv(). */
5197 if (ip->bw_restlen > 0)
5199 /* Need to concatenate the remainder of the previous call and
5200 * the bytes of the current call. Use the end of the
5201 * conversion buffer for this. */
5202 fromlen = len + ip->bw_restlen;
5203 from = (char *)ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
5204 mch_memmove((void *)from, ip->bw_rest, (size_t)ip->bw_restlen);
5205 mch_memmove((void *)(from + ip->bw_restlen), buf, (size_t)len);
5206 tolen = ip->bw_conv_buflen - fromlen;
5208 else
5210 from = (const char *)buf;
5211 fromlen = len;
5212 tolen = ip->bw_conv_buflen;
5214 to = (char *)ip->bw_conv_buf;
5216 if (ip->bw_first)
5218 size_t save_len = tolen;
5220 /* output the initial shift state sequence */
5221 (void)iconv(ip->bw_iconv_fd, NULL, NULL, &to, &tolen);
5223 /* There is a bug in iconv() on Linux (which appears to be
5224 * wide-spread) which sets "to" to NULL and messes up "tolen".
5226 if (to == NULL)
5228 to = (char *)ip->bw_conv_buf;
5229 tolen = save_len;
5231 ip->bw_first = FALSE;
5235 * If iconv() has an error or there is not enough room, fail.
5237 if ((iconv(ip->bw_iconv_fd, (void *)&from, &fromlen, &to, &tolen)
5238 == (size_t)-1 && ICONV_ERRNO != ICONV_EINVAL)
5239 || fromlen > CONV_RESTLEN)
5241 ip->bw_conv_error = TRUE;
5242 return FAIL;
5245 /* copy remainder to ip->bw_rest[] to be used for the next call. */
5246 if (fromlen > 0)
5247 mch_memmove(ip->bw_rest, (void *)from, fromlen);
5248 ip->bw_restlen = (int)fromlen;
5250 buf = ip->bw_conv_buf;
5251 len = (int)((char_u *)to - ip->bw_conv_buf);
5253 # endif
5255 #endif /* FEAT_MBYTE */
5257 #ifdef FEAT_CRYPT
5258 if (flags & FIO_ENCRYPTED) /* encrypt the data */
5260 int ztemp, t, i;
5262 for (i = 0; i < len; i++)
5264 ztemp = buf[i];
5265 buf[i] = ZENCODE(ztemp, t);
5268 #endif
5270 /* Repeat the write(), it may be interrupted by a signal. */
5271 while (len > 0)
5273 wlen = vim_write(ip->bw_fd, buf, len);
5274 if (wlen <= 0) /* error! */
5275 return FAIL;
5276 len -= wlen;
5277 buf += wlen;
5279 return OK;
5282 #ifdef FEAT_MBYTE
5284 * Convert a Unicode character to bytes.
5286 static int
5287 ucs2bytes(c, pp, flags)
5288 unsigned c; /* in: character */
5289 char_u **pp; /* in/out: pointer to result */
5290 int flags; /* FIO_ flags */
5292 char_u *p = *pp;
5293 int error = FALSE;
5294 int cc;
5297 if (flags & FIO_UCS4)
5299 if (flags & FIO_ENDIAN_L)
5301 *p++ = c;
5302 *p++ = (c >> 8);
5303 *p++ = (c >> 16);
5304 *p++ = (c >> 24);
5306 else
5308 *p++ = (c >> 24);
5309 *p++ = (c >> 16);
5310 *p++ = (c >> 8);
5311 *p++ = c;
5314 else if (flags & (FIO_UCS2 | FIO_UTF16))
5316 if (c >= 0x10000)
5318 if (flags & FIO_UTF16)
5320 /* Make two words, ten bits of the character in each. First
5321 * word is 0xd800 - 0xdbff, second one 0xdc00 - 0xdfff */
5322 c -= 0x10000;
5323 if (c >= 0x100000)
5324 error = TRUE;
5325 cc = ((c >> 10) & 0x3ff) + 0xd800;
5326 if (flags & FIO_ENDIAN_L)
5328 *p++ = cc;
5329 *p++ = ((unsigned)cc >> 8);
5331 else
5333 *p++ = ((unsigned)cc >> 8);
5334 *p++ = cc;
5336 c = (c & 0x3ff) + 0xdc00;
5338 else
5339 error = TRUE;
5341 if (flags & FIO_ENDIAN_L)
5343 *p++ = c;
5344 *p++ = (c >> 8);
5346 else
5348 *p++ = (c >> 8);
5349 *p++ = c;
5352 else /* Latin1 */
5354 if (c >= 0x100)
5356 error = TRUE;
5357 *p++ = 0xBF;
5359 else
5360 *p++ = c;
5363 *pp = p;
5364 return error;
5368 * Return TRUE if "a" and "b" are the same 'encoding'.
5369 * Ignores difference between "ansi" and "latin1", "ucs-4" and "ucs-4be", etc.
5371 static int
5372 same_encoding(a, b)
5373 char_u *a;
5374 char_u *b;
5376 int f;
5378 if (STRCMP(a, b) == 0)
5379 return TRUE;
5380 f = get_fio_flags(a);
5381 return (f != 0 && get_fio_flags(b) == f);
5385 * Check "ptr" for a unicode encoding and return the FIO_ flags needed for the
5386 * internal conversion.
5387 * if "ptr" is an empty string, use 'encoding'.
5389 static int
5390 get_fio_flags(ptr)
5391 char_u *ptr;
5393 int prop;
5395 if (*ptr == NUL)
5396 ptr = p_enc;
5398 prop = enc_canon_props(ptr);
5399 if (prop & ENC_UNICODE)
5401 if (prop & ENC_2BYTE)
5403 if (prop & ENC_ENDIAN_L)
5404 return FIO_UCS2 | FIO_ENDIAN_L;
5405 return FIO_UCS2;
5407 if (prop & ENC_4BYTE)
5409 if (prop & ENC_ENDIAN_L)
5410 return FIO_UCS4 | FIO_ENDIAN_L;
5411 return FIO_UCS4;
5413 if (prop & ENC_2WORD)
5415 if (prop & ENC_ENDIAN_L)
5416 return FIO_UTF16 | FIO_ENDIAN_L;
5417 return FIO_UTF16;
5419 return FIO_UTF8;
5421 if (prop & ENC_LATIN1)
5422 return FIO_LATIN1;
5423 /* must be ENC_DBCS, requires iconv() */
5424 return 0;
5427 #ifdef WIN3264
5429 * Check "ptr" for a MS-Windows codepage name and return the FIO_ flags needed
5430 * for the conversion MS-Windows can do for us. Also accept "utf-8".
5431 * Used for conversion between 'encoding' and 'fileencoding'.
5433 static int
5434 get_win_fio_flags(ptr)
5435 char_u *ptr;
5437 int cp;
5439 /* Cannot do this when 'encoding' is not utf-8 and not a codepage. */
5440 if (!enc_utf8 && enc_codepage <= 0)
5441 return 0;
5443 cp = encname2codepage(ptr);
5444 if (cp == 0)
5446 # ifdef CP_UTF8 /* VC 4.1 doesn't define CP_UTF8 */
5447 if (STRCMP(ptr, "utf-8") == 0)
5448 cp = CP_UTF8;
5449 else
5450 # endif
5451 return 0;
5453 return FIO_PUT_CP(cp) | FIO_CODEPAGE;
5455 #endif
5457 #ifdef MACOS_X
5459 * Check "ptr" for a Carbon supported encoding and return the FIO_ flags
5460 * needed for the internal conversion to/from utf-8 or latin1.
5462 static int
5463 get_mac_fio_flags(ptr)
5464 char_u *ptr;
5466 if ((enc_utf8 || STRCMP(p_enc, "latin1") == 0)
5467 && (enc_canon_props(ptr) & ENC_MACROMAN))
5468 return FIO_MACROMAN;
5469 return 0;
5471 #endif
5474 * Check for a Unicode BOM (Byte Order Mark) at the start of p[size].
5475 * "size" must be at least 2.
5476 * Return the name of the encoding and set "*lenp" to the length.
5477 * Returns NULL when no BOM found.
5479 static char_u *
5480 check_for_bom(p, size, lenp, flags)
5481 char_u *p;
5482 long size;
5483 int *lenp;
5484 int flags;
5486 char *name = NULL;
5487 int len = 2;
5489 if (p[0] == 0xef && p[1] == 0xbb && size >= 3 && p[2] == 0xbf
5490 && (flags == FIO_ALL || flags == 0))
5492 name = "utf-8"; /* EF BB BF */
5493 len = 3;
5495 else if (p[0] == 0xff && p[1] == 0xfe)
5497 if (size >= 4 && p[2] == 0 && p[3] == 0
5498 && (flags == FIO_ALL || flags == (FIO_UCS4 | FIO_ENDIAN_L)))
5500 name = "ucs-4le"; /* FF FE 00 00 */
5501 len = 4;
5503 else if (flags == FIO_ALL || flags == (FIO_UCS2 | FIO_ENDIAN_L))
5504 name = "ucs-2le"; /* FF FE */
5505 else if (flags == (FIO_UTF16 | FIO_ENDIAN_L))
5506 name = "utf-16le"; /* FF FE */
5508 else if (p[0] == 0xfe && p[1] == 0xff
5509 && (flags == FIO_ALL || flags == FIO_UCS2 || flags == FIO_UTF16))
5511 if (flags == FIO_UTF16)
5512 name = "utf-16"; /* FE FF */
5513 else
5514 name = "ucs-2"; /* FE FF */
5516 else if (size >= 4 && p[0] == 0 && p[1] == 0 && p[2] == 0xfe
5517 && p[3] == 0xff && (flags == FIO_ALL || flags == FIO_UCS4))
5519 name = "ucs-4"; /* 00 00 FE FF */
5520 len = 4;
5523 *lenp = len;
5524 return (char_u *)name;
5528 * Generate a BOM in "buf[4]" for encoding "name".
5529 * Return the length of the BOM (zero when no BOM).
5531 static int
5532 make_bom(buf, name)
5533 char_u *buf;
5534 char_u *name;
5536 int flags;
5537 char_u *p;
5539 flags = get_fio_flags(name);
5541 /* Can't put a BOM in a non-Unicode file. */
5542 if (flags == FIO_LATIN1 || flags == 0)
5543 return 0;
5545 if (flags == FIO_UTF8) /* UTF-8 */
5547 buf[0] = 0xef;
5548 buf[1] = 0xbb;
5549 buf[2] = 0xbf;
5550 return 3;
5552 p = buf;
5553 (void)ucs2bytes(0xfeff, &p, flags);
5554 return (int)(p - buf);
5556 #endif
5558 #if defined(FEAT_VIMINFO) || defined(FEAT_BROWSE) || \
5559 defined(FEAT_QUICKFIX) || defined(PROTO)
5561 * Try to find a shortname by comparing the fullname with the current
5562 * directory.
5563 * Returns "full_path" or pointer into "full_path" if shortened.
5565 char_u *
5566 shorten_fname1(full_path)
5567 char_u *full_path;
5569 char_u dirname[MAXPATHL];
5570 char_u *p = full_path;
5572 if (mch_dirname(dirname, MAXPATHL) == OK)
5574 p = shorten_fname(full_path, dirname);
5575 if (p == NULL || *p == NUL)
5576 p = full_path;
5578 return p;
5580 #endif
5583 * Try to find a shortname by comparing the fullname with the current
5584 * directory.
5585 * Returns NULL if not shorter name possible, pointer into "full_path"
5586 * otherwise.
5588 char_u *
5589 shorten_fname(full_path, dir_name)
5590 char_u *full_path;
5591 char_u *dir_name;
5593 int len;
5594 char_u *p;
5596 if (full_path == NULL)
5597 return NULL;
5598 len = (int)STRLEN(dir_name);
5599 if (fnamencmp(dir_name, full_path, len) == 0)
5601 p = full_path + len;
5602 #if defined(MSDOS) || defined(MSWIN) || defined(OS2)
5604 * MSDOS: when a file is in the root directory, dir_name will end in a
5605 * slash, since C: by itself does not define a specific dir. In this
5606 * case p may already be correct. <negri>
5608 if (!((len > 2) && (*(p - 2) == ':')))
5609 #endif
5611 if (vim_ispathsep(*p))
5612 ++p;
5613 #ifndef VMS /* the path separator is always part of the path */
5614 else
5615 p = NULL;
5616 #endif
5619 #if defined(MSDOS) || defined(MSWIN) || defined(OS2)
5621 * When using a file in the current drive, remove the drive name:
5622 * "A:\dir\file" -> "\dir\file". This helps when moving a session file on
5623 * a floppy from "A:\dir" to "B:\dir".
5625 else if (len > 3
5626 && TOUPPER_LOC(full_path[0]) == TOUPPER_LOC(dir_name[0])
5627 && full_path[1] == ':'
5628 && vim_ispathsep(full_path[2]))
5629 p = full_path + 2;
5630 #endif
5631 else
5632 p = NULL;
5633 return p;
5637 * Shorten filenames for all buffers.
5638 * When "force" is TRUE: Use full path from now on for files currently being
5639 * edited, both for file name and swap file name. Try to shorten the file
5640 * names a bit, if safe to do so.
5641 * When "force" is FALSE: Only try to shorten absolute file names.
5642 * For buffers that have buftype "nofile" or "scratch": never change the file
5643 * name.
5645 void
5646 shorten_fnames(force)
5647 int force;
5649 char_u dirname[MAXPATHL];
5650 buf_T *buf;
5651 char_u *p;
5653 mch_dirname(dirname, MAXPATHL);
5654 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
5656 if (buf->b_fname != NULL
5657 #ifdef FEAT_QUICKFIX
5658 && !bt_nofile(buf)
5659 #endif
5660 && !path_with_url(buf->b_fname)
5661 && (force
5662 || buf->b_sfname == NULL
5663 || mch_isFullName(buf->b_sfname)))
5665 vim_free(buf->b_sfname);
5666 buf->b_sfname = NULL;
5667 p = shorten_fname(buf->b_ffname, dirname);
5668 if (p != NULL)
5670 buf->b_sfname = vim_strsave(p);
5671 buf->b_fname = buf->b_sfname;
5673 if (p == NULL || buf->b_fname == NULL)
5674 buf->b_fname = buf->b_ffname;
5677 /* Always make the swap file name a full path, a "nofile" buffer may
5678 * also have a swap file. */
5679 mf_fullname(buf->b_ml.ml_mfp);
5681 #ifdef FEAT_WINDOWS
5682 status_redraw_all();
5683 redraw_tabline = TRUE;
5684 #endif
5687 #if (defined(FEAT_DND) && defined(FEAT_GUI_GTK)) \
5688 || defined(FEAT_GUI_MSWIN) \
5689 || defined(FEAT_GUI_MAC) \
5690 || defined(PROTO)
5692 * Shorten all filenames in "fnames[count]" by current directory.
5694 void
5695 shorten_filenames(fnames, count)
5696 char_u **fnames;
5697 int count;
5699 int i;
5700 char_u dirname[MAXPATHL];
5701 char_u *p;
5703 if (fnames == NULL || count < 1)
5704 return;
5705 mch_dirname(dirname, sizeof(dirname));
5706 for (i = 0; i < count; ++i)
5708 if ((p = shorten_fname(fnames[i], dirname)) != NULL)
5710 /* shorten_fname() returns pointer in given "fnames[i]". If free
5711 * "fnames[i]" first, "p" becomes invalid. So we need to copy
5712 * "p" first then free fnames[i]. */
5713 p = vim_strsave(p);
5714 vim_free(fnames[i]);
5715 fnames[i] = p;
5719 #endif
5722 * add extention to file name - change path/fo.o.h to path/fo.o.h.ext or
5723 * fo_o_h.ext for MSDOS or when shortname option set.
5725 * Assumed that fname is a valid name found in the filesystem we assure that
5726 * the return value is a different name and ends in 'ext'.
5727 * "ext" MUST be at most 4 characters long if it starts with a dot, 3
5728 * characters otherwise.
5729 * Space for the returned name is allocated, must be freed later.
5730 * Returns NULL when out of memory.
5732 char_u *
5733 modname(fname, ext, prepend_dot)
5734 char_u *fname, *ext;
5735 int prepend_dot; /* may prepend a '.' to file name */
5737 return buf_modname(
5738 #ifdef SHORT_FNAME
5739 TRUE,
5740 #else
5741 (curbuf->b_p_sn || curbuf->b_shortname),
5742 #endif
5743 fname, ext, prepend_dot);
5746 char_u *
5747 buf_modname(shortname, fname, ext, prepend_dot)
5748 int shortname; /* use 8.3 file name */
5749 char_u *fname, *ext;
5750 int prepend_dot; /* may prepend a '.' to file name */
5752 char_u *retval;
5753 char_u *s;
5754 char_u *e;
5755 char_u *ptr;
5756 int fnamelen, extlen;
5758 extlen = (int)STRLEN(ext);
5761 * If there is no file name we must get the name of the current directory
5762 * (we need the full path in case :cd is used).
5764 if (fname == NULL || *fname == NUL)
5766 retval = alloc((unsigned)(MAXPATHL + extlen + 3));
5767 if (retval == NULL)
5768 return NULL;
5769 if (mch_dirname(retval, MAXPATHL) == FAIL ||
5770 (fnamelen = (int)STRLEN(retval)) == 0)
5772 vim_free(retval);
5773 return NULL;
5775 if (!after_pathsep(retval, retval + fnamelen))
5777 retval[fnamelen++] = PATHSEP;
5778 retval[fnamelen] = NUL;
5780 #ifndef SHORT_FNAME
5781 prepend_dot = FALSE; /* nothing to prepend a dot to */
5782 #endif
5784 else
5786 fnamelen = (int)STRLEN(fname);
5787 retval = alloc((unsigned)(fnamelen + extlen + 3));
5788 if (retval == NULL)
5789 return NULL;
5790 STRCPY(retval, fname);
5791 #ifdef VMS
5792 vms_remove_version(retval); /* we do not need versions here */
5793 #endif
5797 * search backwards until we hit a '/', '\' or ':' replacing all '.'
5798 * by '_' for MSDOS or when shortname option set and ext starts with a dot.
5799 * Then truncate what is after the '/', '\' or ':' to 8 characters for
5800 * MSDOS and 26 characters for AMIGA, a lot more for UNIX.
5802 for (ptr = retval + fnamelen; ptr > retval; mb_ptr_back(retval, ptr))
5804 #ifndef RISCOS
5805 if (*ext == '.'
5806 # ifdef USE_LONG_FNAME
5807 && (!USE_LONG_FNAME || shortname)
5808 # else
5809 # ifndef SHORT_FNAME
5810 && shortname
5811 # endif
5812 # endif
5814 if (*ptr == '.') /* replace '.' by '_' */
5815 *ptr = '_';
5816 #endif
5817 if (vim_ispathsep(*ptr))
5819 ++ptr;
5820 break;
5824 /* the file name has at most BASENAMELEN characters. */
5825 #ifndef SHORT_FNAME
5826 if (STRLEN(ptr) > (unsigned)BASENAMELEN)
5827 ptr[BASENAMELEN] = '\0';
5828 #endif
5830 s = ptr + STRLEN(ptr);
5833 * For 8.3 file names we may have to reduce the length.
5835 #ifdef USE_LONG_FNAME
5836 if (!USE_LONG_FNAME || shortname)
5837 #else
5838 # ifndef SHORT_FNAME
5839 if (shortname)
5840 # endif
5841 #endif
5844 * If there is no file name, or the file name ends in '/', and the
5845 * extension starts with '.', put a '_' before the dot, because just
5846 * ".ext" is invalid.
5848 if (fname == NULL || *fname == NUL
5849 || vim_ispathsep(fname[STRLEN(fname) - 1]))
5851 #ifdef RISCOS
5852 if (*ext == '/')
5853 #else
5854 if (*ext == '.')
5855 #endif
5856 *s++ = '_';
5859 * If the extension starts with '.', truncate the base name at 8
5860 * characters
5862 #ifdef RISCOS
5863 /* We normally use '/', but swap files are '_' */
5864 else if (*ext == '/' || *ext == '_')
5865 #else
5866 else if (*ext == '.')
5867 #endif
5869 if (s - ptr > (size_t)8)
5871 s = ptr + 8;
5872 *s = '\0';
5876 * If the extension doesn't start with '.', and the file name
5877 * doesn't have an extension yet, append a '.'
5879 #ifdef RISCOS
5880 else if ((e = vim_strchr(ptr, '/')) == NULL)
5881 *s++ = '/';
5882 #else
5883 else if ((e = vim_strchr(ptr, '.')) == NULL)
5884 *s++ = '.';
5885 #endif
5887 * If the extension doesn't start with '.', and there already is an
5888 * extension, it may need to be truncated
5890 else if ((int)STRLEN(e) + extlen > 4)
5891 s = e + 4 - extlen;
5893 #if defined(OS2) || defined(USE_LONG_FNAME) || defined(WIN3264)
5895 * If there is no file name, and the extension starts with '.', put a
5896 * '_' before the dot, because just ".ext" may be invalid if it's on a
5897 * FAT partition, and on HPFS it doesn't matter.
5899 else if ((fname == NULL || *fname == NUL) && *ext == '.')
5900 *s++ = '_';
5901 #endif
5904 * Append the extention.
5905 * ext can start with '.' and cannot exceed 3 more characters.
5907 STRCPY(s, ext);
5909 #ifndef SHORT_FNAME
5911 * Prepend the dot.
5913 if (prepend_dot && !shortname && *(e = gettail(retval)) !=
5914 #ifdef RISCOS
5916 #else
5918 #endif
5919 #ifdef USE_LONG_FNAME
5920 && USE_LONG_FNAME
5921 #endif
5924 mch_memmove(e + 1, e, STRLEN(e) + 1);
5925 #ifdef RISCOS
5926 *e = '/';
5927 #else
5928 *e = '.';
5929 #endif
5931 #endif
5934 * Check that, after appending the extension, the file name is really
5935 * different.
5937 if (fname != NULL && STRCMP(fname, retval) == 0)
5939 /* we search for a character that can be replaced by '_' */
5940 while (--s >= ptr)
5942 if (*s != '_')
5944 *s = '_';
5945 break;
5948 if (s < ptr) /* fname was "________.<ext>", how tricky! */
5949 *ptr = 'v';
5951 return retval;
5955 * Like fgets(), but if the file line is too long, it is truncated and the
5956 * rest of the line is thrown away. Returns TRUE for end-of-file.
5959 vim_fgets(buf, size, fp)
5960 char_u *buf;
5961 int size;
5962 FILE *fp;
5964 char *eof;
5965 #define FGETS_SIZE 200
5966 char tbuf[FGETS_SIZE];
5968 buf[size - 2] = NUL;
5969 #ifdef USE_CR
5970 eof = fgets_cr((char *)buf, size, fp);
5971 #else
5972 eof = fgets((char *)buf, size, fp);
5973 #endif
5974 if (buf[size - 2] != NUL && buf[size - 2] != '\n')
5976 buf[size - 1] = NUL; /* Truncate the line */
5978 /* Now throw away the rest of the line: */
5981 tbuf[FGETS_SIZE - 2] = NUL;
5982 #ifdef USE_CR
5983 fgets_cr((char *)tbuf, FGETS_SIZE, fp);
5984 #else
5985 fgets((char *)tbuf, FGETS_SIZE, fp);
5986 #endif
5987 } while (tbuf[FGETS_SIZE - 2] != NUL && tbuf[FGETS_SIZE - 2] != '\n');
5989 return (eof == NULL);
5992 #if defined(USE_CR) || defined(PROTO)
5994 * Like vim_fgets(), but accept any line terminator: CR, CR-LF or LF.
5995 * Returns TRUE for end-of-file.
5996 * Only used for the Mac, because it's much slower than vim_fgets().
5999 tag_fgets(buf, size, fp)
6000 char_u *buf;
6001 int size;
6002 FILE *fp;
6004 int i = 0;
6005 int c;
6006 int eof = FALSE;
6008 for (;;)
6010 c = fgetc(fp);
6011 if (c == EOF)
6013 eof = TRUE;
6014 break;
6016 if (c == '\r')
6018 /* Always store a NL for end-of-line. */
6019 if (i < size - 1)
6020 buf[i++] = '\n';
6021 c = fgetc(fp);
6022 if (c != '\n') /* Macintosh format: single CR. */
6023 ungetc(c, fp);
6024 break;
6026 if (i < size - 1)
6027 buf[i++] = c;
6028 if (c == '\n')
6029 break;
6031 buf[i] = NUL;
6032 return eof;
6034 #endif
6037 * rename() only works if both files are on the same file system, this
6038 * function will (attempts to?) copy the file across if rename fails -- webb
6039 * Return -1 for failure, 0 for success.
6042 vim_rename(from, to)
6043 char_u *from;
6044 char_u *to;
6046 int fd_in;
6047 int fd_out;
6048 int n;
6049 char *errmsg = NULL;
6050 char *buffer;
6051 #ifdef AMIGA
6052 BPTR flock;
6053 #endif
6054 struct stat st;
6055 long perm;
6056 #ifdef HAVE_ACL
6057 vim_acl_T acl; /* ACL from original file */
6058 #endif
6061 * When the names are identical, there is nothing to do.
6063 if (fnamecmp(from, to) == 0)
6064 return 0;
6067 * Fail if the "from" file doesn't exist. Avoids that "to" is deleted.
6069 if (mch_stat((char *)from, &st) < 0)
6070 return -1;
6073 * Delete the "to" file, this is required on some systems to make the
6074 * mch_rename() work, on other systems it makes sure that we don't have
6075 * two files when the mch_rename() fails.
6078 #ifdef AMIGA
6080 * With MSDOS-compatible filesystems (crossdos, messydos) it is possible
6081 * that the name of the "to" file is the same as the "from" file, even
6082 * though the names are different. To avoid the chance of accidentally
6083 * deleting the "from" file (horror!) we lock it during the remove.
6085 * When used for making a backup before writing the file: This should not
6086 * happen with ":w", because startscript() should detect this problem and
6087 * set buf->b_shortname, causing modname() to return a correct ".bak" file
6088 * name. This problem does exist with ":w filename", but then the
6089 * original file will be somewhere else so the backup isn't really
6090 * important. If autoscripting is off the rename may fail.
6092 flock = Lock((UBYTE *)from, (long)ACCESS_READ);
6093 #endif
6094 mch_remove(to);
6095 #ifdef AMIGA
6096 if (flock)
6097 UnLock(flock);
6098 #endif
6101 * First try a normal rename, return if it works.
6103 if (mch_rename((char *)from, (char *)to) == 0)
6104 return 0;
6107 * Rename() failed, try copying the file.
6109 perm = mch_getperm(from);
6110 #ifdef HAVE_ACL
6111 /* For systems that support ACL: get the ACL from the original file. */
6112 acl = mch_get_acl(from);
6113 #endif
6114 fd_in = mch_open((char *)from, O_RDONLY|O_EXTRA, 0);
6115 if (fd_in == -1)
6116 return -1;
6118 /* Create the new file with same permissions as the original. */
6119 fd_out = mch_open((char *)to,
6120 O_CREAT|O_EXCL|O_WRONLY|O_EXTRA|O_NOFOLLOW, (int)perm);
6121 if (fd_out == -1)
6123 close(fd_in);
6124 return -1;
6127 buffer = (char *)alloc(BUFSIZE);
6128 if (buffer == NULL)
6130 close(fd_in);
6131 close(fd_out);
6132 return -1;
6135 while ((n = vim_read(fd_in, buffer, BUFSIZE)) > 0)
6136 if (vim_write(fd_out, buffer, n) != n)
6138 errmsg = _("E208: Error writing to \"%s\"");
6139 break;
6142 vim_free(buffer);
6143 close(fd_in);
6144 if (close(fd_out) < 0)
6145 errmsg = _("E209: Error closing \"%s\"");
6146 if (n < 0)
6148 errmsg = _("E210: Error reading \"%s\"");
6149 to = from;
6151 #ifndef UNIX /* for Unix mch_open() already set the permission */
6152 mch_setperm(to, perm);
6153 #endif
6154 #ifdef HAVE_ACL
6155 mch_set_acl(to, acl);
6156 #endif
6157 if (errmsg != NULL)
6159 EMSG2(errmsg, to);
6160 return -1;
6162 mch_remove(from);
6163 return 0;
6166 static int already_warned = FALSE;
6169 * Check if any not hidden buffer has been changed.
6170 * Postpone the check if there are characters in the stuff buffer, a global
6171 * command is being executed, a mapping is being executed or an autocommand is
6172 * busy.
6173 * Returns TRUE if some message was written (screen should be redrawn and
6174 * cursor positioned).
6177 check_timestamps(focus)
6178 int focus; /* called for GUI focus event */
6180 buf_T *buf;
6181 int didit = 0;
6182 int n;
6184 /* Don't check timestamps while system() or another low-level function may
6185 * cause us to lose and gain focus. */
6186 if (no_check_timestamps > 0)
6187 return FALSE;
6189 /* Avoid doing a check twice. The OK/Reload dialog can cause a focus
6190 * event and we would keep on checking if the file is steadily growing.
6191 * Do check again after typing something. */
6192 if (focus && did_check_timestamps)
6194 need_check_timestamps = TRUE;
6195 return FALSE;
6198 if (!stuff_empty() || global_busy || !typebuf_typed()
6199 #ifdef FEAT_AUTOCMD
6200 || autocmd_busy || curbuf_lock > 0
6201 #endif
6203 need_check_timestamps = TRUE; /* check later */
6204 else
6206 ++no_wait_return;
6207 did_check_timestamps = TRUE;
6208 already_warned = FALSE;
6209 for (buf = firstbuf; buf != NULL; )
6211 /* Only check buffers in a window. */
6212 if (buf->b_nwindows > 0)
6214 n = buf_check_timestamp(buf, focus);
6215 if (didit < n)
6216 didit = n;
6217 if (n > 0 && !buf_valid(buf))
6219 /* Autocommands have removed the buffer, start at the
6220 * first one again. */
6221 buf = firstbuf;
6222 continue;
6225 buf = buf->b_next;
6227 --no_wait_return;
6228 need_check_timestamps = FALSE;
6229 if (need_wait_return && didit == 2)
6231 /* make sure msg isn't overwritten */
6232 msg_puts((char_u *)"\n");
6233 out_flush();
6236 return didit;
6240 * Move all the lines from buffer "frombuf" to buffer "tobuf".
6241 * Return OK or FAIL. When FAIL "tobuf" is incomplete and/or "frombuf" is not
6242 * empty.
6244 static int
6245 move_lines(frombuf, tobuf)
6246 buf_T *frombuf;
6247 buf_T *tobuf;
6249 buf_T *tbuf = curbuf;
6250 int retval = OK;
6251 linenr_T lnum;
6252 char_u *p;
6254 /* Copy the lines in "frombuf" to "tobuf". */
6255 curbuf = tobuf;
6256 for (lnum = 1; lnum <= frombuf->b_ml.ml_line_count; ++lnum)
6258 p = vim_strsave(ml_get_buf(frombuf, lnum, FALSE));
6259 if (p == NULL || ml_append(lnum - 1, p, 0, FALSE) == FAIL)
6261 vim_free(p);
6262 retval = FAIL;
6263 break;
6265 vim_free(p);
6268 /* Delete all the lines in "frombuf". */
6269 if (retval != FAIL)
6271 curbuf = frombuf;
6272 for (lnum = curbuf->b_ml.ml_line_count; lnum > 0; --lnum)
6273 if (ml_delete(lnum, FALSE) == FAIL)
6275 /* Oops! We could try putting back the saved lines, but that
6276 * might fail again... */
6277 retval = FAIL;
6278 break;
6282 curbuf = tbuf;
6283 return retval;
6287 * Check if buffer "buf" has been changed.
6288 * Also check if the file for a new buffer unexpectedly appeared.
6289 * return 1 if a changed buffer was found.
6290 * return 2 if a message has been displayed.
6291 * return 0 otherwise.
6293 /*ARGSUSED*/
6295 buf_check_timestamp(buf, focus)
6296 buf_T *buf;
6297 int focus; /* called for GUI focus event */
6299 struct stat st;
6300 int stat_res;
6301 int retval = 0;
6302 char_u *path;
6303 char_u *tbuf;
6304 char *mesg = NULL;
6305 char *mesg2 = "";
6306 int helpmesg = FALSE;
6307 int reload = FALSE;
6308 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6309 int can_reload = FALSE;
6310 #endif
6311 size_t orig_size = buf->b_orig_size;
6312 int orig_mode = buf->b_orig_mode;
6313 #ifdef FEAT_GUI
6314 int save_mouse_correct = need_mouse_correct;
6315 #endif
6316 #ifdef FEAT_AUTOCMD
6317 static int busy = FALSE;
6318 int n;
6319 char_u *s;
6320 #endif
6321 char *reason;
6323 /* If there is no file name, the buffer is not loaded, 'buftype' is
6324 * set, we are in the middle of a save or being called recursively: ignore
6325 * this buffer. */
6326 if (buf->b_ffname == NULL
6327 || buf->b_ml.ml_mfp == NULL
6328 #if defined(FEAT_QUICKFIX)
6329 || *buf->b_p_bt != NUL
6330 #endif
6331 || buf->b_saving
6332 #ifdef FEAT_AUTOCMD
6333 || busy
6334 #endif
6335 #ifdef FEAT_NETBEANS_INTG
6336 || isNetbeansBuffer(buf)
6337 #endif
6339 return 0;
6341 if ( !(buf->b_flags & BF_NOTEDITED)
6342 && buf->b_mtime != 0
6343 && ((stat_res = mch_stat((char *)buf->b_ffname, &st)) < 0
6344 || time_differs((long)st.st_mtime, buf->b_mtime)
6345 #ifdef HAVE_ST_MODE
6346 || (int)st.st_mode != buf->b_orig_mode
6347 #else
6348 || mch_getperm(buf->b_ffname) != buf->b_orig_mode
6349 #endif
6352 retval = 1;
6354 /* set b_mtime to stop further warnings (e.g., when executing
6355 * FileChangedShell autocmd) */
6356 if (stat_res < 0)
6358 buf->b_mtime = 0;
6359 buf->b_orig_size = 0;
6360 buf->b_orig_mode = 0;
6362 else
6363 buf_store_time(buf, &st, buf->b_ffname);
6365 /* Don't do anything for a directory. Might contain the file
6366 * explorer. */
6367 if (mch_isdir(buf->b_fname))
6371 * If 'autoread' is set, the buffer has no changes and the file still
6372 * exists, reload the buffer. Use the buffer-local option value if it
6373 * was set, the global option value otherwise.
6375 else if ((buf->b_p_ar >= 0 ? buf->b_p_ar : p_ar)
6376 && !bufIsChanged(buf) && stat_res >= 0)
6377 reload = TRUE;
6378 else
6380 if (stat_res < 0)
6381 reason = "deleted";
6382 else if (bufIsChanged(buf))
6383 reason = "conflict";
6384 else if (orig_size != buf->b_orig_size || buf_contents_changed(buf))
6385 reason = "changed";
6386 else if (orig_mode != buf->b_orig_mode)
6387 reason = "mode";
6388 else
6389 reason = "time";
6391 #ifdef FEAT_AUTOCMD
6393 * Only give the warning if there are no FileChangedShell
6394 * autocommands.
6395 * Avoid being called recursively by setting "busy".
6397 busy = TRUE;
6398 # ifdef FEAT_EVAL
6399 set_vim_var_string(VV_FCS_REASON, (char_u *)reason, -1);
6400 set_vim_var_string(VV_FCS_CHOICE, (char_u *)"", -1);
6401 # endif
6402 n = apply_autocmds(EVENT_FILECHANGEDSHELL,
6403 buf->b_fname, buf->b_fname, FALSE, buf);
6404 busy = FALSE;
6405 if (n)
6407 if (!buf_valid(buf))
6408 EMSG(_("E246: FileChangedShell autocommand deleted buffer"));
6409 # ifdef FEAT_EVAL
6410 s = get_vim_var_str(VV_FCS_CHOICE);
6411 if (STRCMP(s, "reload") == 0 && *reason != 'd')
6412 reload = TRUE;
6413 else if (STRCMP(s, "ask") == 0)
6414 n = FALSE;
6415 else
6416 # endif
6417 return 2;
6419 if (!n)
6420 #endif
6422 if (*reason == 'd')
6423 mesg = _("E211: File \"%s\" no longer available");
6424 else
6426 helpmesg = TRUE;
6427 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6428 can_reload = TRUE;
6429 #endif
6431 * Check if the file contents really changed to avoid
6432 * giving a warning when only the timestamp was set (e.g.,
6433 * checked out of CVS). Always warn when the buffer was
6434 * changed.
6436 if (reason[2] == 'n')
6438 mesg = _("W12: Warning: File \"%s\" has changed and the buffer was changed in Vim as well");
6439 mesg2 = _("See \":help W12\" for more info.");
6441 else if (reason[1] == 'h')
6443 mesg = _("W11: Warning: File \"%s\" has changed since editing started");
6444 mesg2 = _("See \":help W11\" for more info.");
6446 else if (*reason == 'm')
6448 mesg = _("W16: Warning: Mode of file \"%s\" has changed since editing started");
6449 mesg2 = _("See \":help W16\" for more info.");
6451 /* Else: only timestamp changed, ignored */
6457 else if ((buf->b_flags & BF_NEW) && !(buf->b_flags & BF_NEW_W)
6458 && vim_fexists(buf->b_ffname))
6460 retval = 1;
6461 mesg = _("W13: Warning: File \"%s\" has been created after editing started");
6462 buf->b_flags |= BF_NEW_W;
6463 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6464 can_reload = TRUE;
6465 #endif
6468 if (mesg != NULL)
6470 path = home_replace_save(buf, buf->b_fname);
6471 if (path != NULL)
6473 if (!helpmesg)
6474 mesg2 = "";
6475 tbuf = alloc((unsigned)(STRLEN(path) + STRLEN(mesg)
6476 + STRLEN(mesg2) + 2));
6477 sprintf((char *)tbuf, mesg, path);
6478 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
6479 if (can_reload)
6481 if (*mesg2 != NUL)
6483 STRCAT(tbuf, "\n");
6484 STRCAT(tbuf, mesg2);
6486 if (do_dialog(VIM_WARNING, (char_u *)_("Warning"), tbuf,
6487 (char_u *)_("&OK\n&Load File"), 1, NULL) == 2)
6488 reload = TRUE;
6490 else
6491 #endif
6492 if (State > NORMAL_BUSY || (State & CMDLINE) || already_warned)
6494 if (*mesg2 != NUL)
6496 STRCAT(tbuf, "; ");
6497 STRCAT(tbuf, mesg2);
6499 EMSG(tbuf);
6500 retval = 2;
6502 else
6504 # ifdef FEAT_AUTOCMD
6505 if (!autocmd_busy)
6506 # endif
6508 msg_start();
6509 msg_puts_attr(tbuf, hl_attr(HLF_E) + MSG_HIST);
6510 if (*mesg2 != NUL)
6511 msg_puts_attr((char_u *)mesg2,
6512 hl_attr(HLF_W) + MSG_HIST);
6513 msg_clr_eos();
6514 (void)msg_end();
6515 if (emsg_silent == 0)
6517 out_flush();
6518 # ifdef FEAT_GUI
6519 if (!focus)
6520 # endif
6521 /* give the user some time to think about it */
6522 ui_delay(1000L, TRUE);
6524 /* don't redraw and erase the message */
6525 redraw_cmdline = FALSE;
6528 already_warned = TRUE;
6531 vim_free(path);
6532 vim_free(tbuf);
6536 if (reload)
6537 /* Reload the buffer. */
6538 buf_reload(buf, orig_mode);
6540 #ifdef FEAT_AUTOCMD
6541 if (buf_valid(buf))
6542 (void)apply_autocmds(EVENT_FILECHANGEDSHELLPOST,
6543 buf->b_fname, buf->b_fname, FALSE, buf);
6544 #endif
6545 #ifdef FEAT_GUI
6546 /* restore this in case an autocommand has set it; it would break
6547 * 'mousefocus' */
6548 need_mouse_correct = save_mouse_correct;
6549 #endif
6551 return retval;
6555 * Reload a buffer that is already loaded.
6556 * Used when the file was changed outside of Vim.
6557 * "orig_mode" is buf->b_orig_mode before the need for reloading was detected.
6558 * buf->b_orig_mode may have been reset already.
6560 void
6561 buf_reload(buf, orig_mode)
6562 buf_T *buf;
6563 int orig_mode;
6565 exarg_T ea;
6566 pos_T old_cursor;
6567 linenr_T old_topline;
6568 int old_ro = buf->b_p_ro;
6569 buf_T *savebuf;
6570 int saved = OK;
6571 aco_save_T aco;
6573 /* set curwin/curbuf for "buf" and save some things */
6574 aucmd_prepbuf(&aco, buf);
6576 /* We only want to read the text from the file, not reset the syntax
6577 * highlighting, clear marks, diff status, etc. Force the fileformat
6578 * and encoding to be the same. */
6579 if (prep_exarg(&ea, buf) == OK)
6581 old_cursor = curwin->w_cursor;
6582 old_topline = curwin->w_topline;
6585 * To behave like when a new file is edited (matters for
6586 * BufReadPost autocommands) we first need to delete the current
6587 * buffer contents. But if reading the file fails we should keep
6588 * the old contents. Can't use memory only, the file might be
6589 * too big. Use a hidden buffer to move the buffer contents to.
6591 if (bufempty())
6592 savebuf = NULL;
6593 else
6595 /* Allocate a buffer without putting it in the buffer list. */
6596 savebuf = buflist_new(NULL, NULL, (linenr_T)1, BLN_DUMMY);
6597 if (savebuf != NULL && buf == curbuf)
6599 /* Open the memline. */
6600 curbuf = savebuf;
6601 curwin->w_buffer = savebuf;
6602 saved = ml_open(curbuf);
6603 curbuf = buf;
6604 curwin->w_buffer = buf;
6606 if (savebuf == NULL || saved == FAIL || buf != curbuf
6607 || move_lines(buf, savebuf) == FAIL)
6609 EMSG2(_("E462: Could not prepare for reloading \"%s\""),
6610 buf->b_fname);
6611 saved = FAIL;
6615 if (saved == OK)
6617 curbuf->b_flags |= BF_CHECK_RO; /* check for RO again */
6618 #ifdef FEAT_AUTOCMD
6619 keep_filetype = TRUE; /* don't detect 'filetype' */
6620 #endif
6621 if (readfile(buf->b_ffname, buf->b_fname, (linenr_T)0,
6622 (linenr_T)0,
6623 (linenr_T)MAXLNUM, &ea, READ_NEW) == FAIL)
6625 #if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
6626 if (!aborting())
6627 #endif
6628 EMSG2(_("E321: Could not reload \"%s\""), buf->b_fname);
6629 if (savebuf != NULL && buf_valid(savebuf) && buf == curbuf)
6631 /* Put the text back from the save buffer. First
6632 * delete any lines that readfile() added. */
6633 while (!bufempty())
6634 if (ml_delete(buf->b_ml.ml_line_count, FALSE) == FAIL)
6635 break;
6636 (void)move_lines(savebuf, buf);
6639 else if (buf == curbuf)
6641 /* Mark the buffer as unmodified and free undo info. */
6642 unchanged(buf, TRUE);
6643 u_blockfree(buf);
6644 u_clearall(buf);
6647 vim_free(ea.cmd);
6649 if (savebuf != NULL && buf_valid(savebuf))
6650 wipe_buffer(savebuf, FALSE);
6652 #ifdef FEAT_DIFF
6653 /* Invalidate diff info if necessary. */
6654 diff_invalidate(curbuf);
6655 #endif
6657 /* Restore the topline and cursor position and check it (lines may
6658 * have been removed). */
6659 if (old_topline > curbuf->b_ml.ml_line_count)
6660 curwin->w_topline = curbuf->b_ml.ml_line_count;
6661 else
6662 curwin->w_topline = old_topline;
6663 curwin->w_cursor = old_cursor;
6664 check_cursor();
6665 update_topline();
6666 #ifdef FEAT_AUTOCMD
6667 keep_filetype = FALSE;
6668 #endif
6669 #ifdef FEAT_FOLDING
6671 win_T *wp;
6673 /* Update folds unless they are defined manually. */
6674 FOR_ALL_WINDOWS(wp)
6675 if (wp->w_buffer == curwin->w_buffer
6676 && !foldmethodIsManual(wp))
6677 foldUpdateAll(wp);
6679 #endif
6680 /* If the mode didn't change and 'readonly' was set, keep the old
6681 * value; the user probably used the ":view" command. But don't
6682 * reset it, might have had a read error. */
6683 if (orig_mode == curbuf->b_orig_mode)
6684 curbuf->b_p_ro |= old_ro;
6687 /* restore curwin/curbuf and a few other things */
6688 aucmd_restbuf(&aco);
6689 /* Careful: autocommands may have made "buf" invalid! */
6692 /*ARGSUSED*/
6693 void
6694 buf_store_time(buf, st, fname)
6695 buf_T *buf;
6696 struct stat *st;
6697 char_u *fname;
6699 buf->b_mtime = (long)st->st_mtime;
6700 buf->b_orig_size = (size_t)st->st_size;
6701 #ifdef HAVE_ST_MODE
6702 buf->b_orig_mode = (int)st->st_mode;
6703 #else
6704 buf->b_orig_mode = mch_getperm(fname);
6705 #endif
6709 * Adjust the line with missing eol, used for the next write.
6710 * Used for do_filter(), when the input lines for the filter are deleted.
6712 void
6713 write_lnum_adjust(offset)
6714 linenr_T offset;
6716 if (write_no_eol_lnum != 0) /* only if there is a missing eol */
6717 write_no_eol_lnum += offset;
6720 #if defined(TEMPDIRNAMES) || defined(PROTO)
6721 static long temp_count = 0; /* Temp filename counter. */
6724 * Delete the temp directory and all files it contains.
6726 void
6727 vim_deltempdir()
6729 char_u **files;
6730 int file_count;
6731 int i;
6733 if (vim_tempdir != NULL)
6735 sprintf((char *)NameBuff, "%s*", vim_tempdir);
6736 if (gen_expand_wildcards(1, &NameBuff, &file_count, &files,
6737 EW_DIR|EW_FILE|EW_SILENT) == OK)
6739 for (i = 0; i < file_count; ++i)
6740 mch_remove(files[i]);
6741 FreeWild(file_count, files);
6743 gettail(NameBuff)[-1] = NUL;
6744 (void)mch_rmdir(NameBuff);
6746 vim_free(vim_tempdir);
6747 vim_tempdir = NULL;
6750 #endif
6753 * vim_tempname(): Return a unique name that can be used for a temp file.
6755 * The temp file is NOT created.
6757 * The returned pointer is to allocated memory.
6758 * The returned pointer is NULL if no valid name was found.
6760 /*ARGSUSED*/
6761 char_u *
6762 vim_tempname(extra_char)
6763 int extra_char; /* character to use in the name instead of '?' */
6765 #ifdef USE_TMPNAM
6766 char_u itmp[L_tmpnam]; /* use tmpnam() */
6767 #else
6768 char_u itmp[TEMPNAMELEN];
6769 #endif
6771 #ifdef TEMPDIRNAMES
6772 static char *(tempdirs[]) = {TEMPDIRNAMES};
6773 int i;
6774 long nr;
6775 long off;
6776 # ifndef EEXIST
6777 struct stat st;
6778 # endif
6781 * This will create a directory for private use by this instance of Vim.
6782 * This is done once, and the same directory is used for all temp files.
6783 * This method avoids security problems because of symlink attacks et al.
6784 * It's also a bit faster, because we only need to check for an existing
6785 * file when creating the directory and not for each temp file.
6787 if (vim_tempdir == NULL)
6790 * Try the entries in TEMPDIRNAMES to create the temp directory.
6792 for (i = 0; i < sizeof(tempdirs) / sizeof(char *); ++i)
6794 /* expand $TMP, leave room for "/v1100000/999999999" */
6795 expand_env((char_u *)tempdirs[i], itmp, TEMPNAMELEN - 20);
6796 if (mch_isdir(itmp)) /* directory exists */
6798 # ifdef __EMX__
6799 /* If $TMP contains a forward slash (perhaps using bash or
6800 * tcsh), don't add a backslash, use a forward slash!
6801 * Adding 2 backslashes didn't work. */
6802 if (vim_strchr(itmp, '/') != NULL)
6803 STRCAT(itmp, "/");
6804 else
6805 # endif
6806 add_pathsep(itmp);
6808 /* Get an arbitrary number of up to 6 digits. When it's
6809 * unlikely that it already exists it will be faster,
6810 * otherwise it doesn't matter. The use of mkdir() avoids any
6811 * security problems because of the predictable number. */
6812 nr = (mch_get_pid() + (long)time(NULL)) % 1000000L;
6814 /* Try up to 10000 different values until we find a name that
6815 * doesn't exist. */
6816 for (off = 0; off < 10000L; ++off)
6818 int r;
6819 #if defined(UNIX) || defined(VMS)
6820 mode_t umask_save;
6821 #endif
6823 sprintf((char *)itmp + STRLEN(itmp), "v%ld", nr + off);
6824 # ifndef EEXIST
6825 /* If mkdir() does not set errno to EEXIST, check for
6826 * existing file here. There is a race condition then,
6827 * although it's fail-safe. */
6828 if (mch_stat((char *)itmp, &st) >= 0)
6829 continue;
6830 # endif
6831 #if defined(UNIX) || defined(VMS)
6832 /* Make sure the umask doesn't remove the executable bit.
6833 * "repl" has been reported to use "177". */
6834 umask_save = umask(077);
6835 #endif
6836 r = vim_mkdir(itmp, 0700);
6837 #if defined(UNIX) || defined(VMS)
6838 (void)umask(umask_save);
6839 #endif
6840 if (r == 0)
6842 char_u *buf;
6844 /* Directory was created, use this name.
6845 * Expand to full path; When using the current
6846 * directory a ":cd" would confuse us. */
6847 buf = alloc((unsigned)MAXPATHL + 1);
6848 if (buf != NULL)
6850 if (vim_FullName(itmp, buf, MAXPATHL, FALSE)
6851 == FAIL)
6852 STRCPY(buf, itmp);
6853 # ifdef __EMX__
6854 if (vim_strchr(buf, '/') != NULL)
6855 STRCAT(buf, "/");
6856 else
6857 # endif
6858 add_pathsep(buf);
6859 vim_tempdir = vim_strsave(buf);
6860 vim_free(buf);
6862 break;
6864 # ifdef EEXIST
6865 /* If the mkdir() didn't fail because the file/dir exists,
6866 * we probably can't create any dir here, try another
6867 * place. */
6868 if (errno != EEXIST)
6869 # endif
6870 break;
6872 if (vim_tempdir != NULL)
6873 break;
6878 if (vim_tempdir != NULL)
6880 /* There is no need to check if the file exists, because we own the
6881 * directory and nobody else creates a file in it. */
6882 sprintf((char *)itmp, "%s%ld", vim_tempdir, temp_count++);
6883 return vim_strsave(itmp);
6886 return NULL;
6888 #else /* TEMPDIRNAMES */
6890 # ifdef WIN3264
6891 char szTempFile[_MAX_PATH + 1];
6892 char buf4[4];
6893 char_u *retval;
6894 char_u *p;
6896 STRCPY(itmp, "");
6897 if (GetTempPath(_MAX_PATH, szTempFile) == 0)
6898 szTempFile[0] = NUL; /* GetTempPath() failed, use current dir */
6899 strcpy(buf4, "VIM");
6900 buf4[2] = extra_char; /* make it "VIa", "VIb", etc. */
6901 if (GetTempFileName(szTempFile, buf4, 0, itmp) == 0)
6902 return NULL;
6903 /* GetTempFileName() will create the file, we don't want that */
6904 (void)DeleteFile(itmp);
6906 /* Backslashes in a temp file name cause problems when filtering with
6907 * "sh". NOTE: This also checks 'shellcmdflag' to help those people who
6908 * didn't set 'shellslash'. */
6909 retval = vim_strsave(itmp);
6910 if (*p_shcf == '-' || p_ssl)
6911 for (p = retval; *p; ++p)
6912 if (*p == '\\')
6913 *p = '/';
6914 return retval;
6916 # else /* WIN3264 */
6918 # ifdef USE_TMPNAM
6919 /* tmpnam() will make its own name */
6920 if (*tmpnam((char *)itmp) == NUL)
6921 return NULL;
6922 # else
6923 char_u *p;
6925 # ifdef VMS_TEMPNAM
6926 /* mktemp() is not working on VMS. It seems to be
6927 * a do-nothing function. Therefore we use tempnam().
6929 sprintf((char *)itmp, "VIM%c", extra_char);
6930 p = (char_u *)tempnam("tmp:", (char *)itmp);
6931 if (p != NULL)
6933 /* VMS will use '.LOG' if we don't explicitly specify an extension,
6934 * and VIM will then be unable to find the file later */
6935 STRCPY(itmp, p);
6936 STRCAT(itmp, ".txt");
6937 free(p);
6939 else
6940 return NULL;
6941 # else
6942 STRCPY(itmp, TEMPNAME);
6943 if ((p = vim_strchr(itmp, '?')) != NULL)
6944 *p = extra_char;
6945 if (mktemp((char *)itmp) == NULL)
6946 return NULL;
6947 # endif
6948 # endif
6950 return vim_strsave(itmp);
6951 # endif /* WIN3264 */
6952 #endif /* TEMPDIRNAMES */
6955 #if defined(BACKSLASH_IN_FILENAME) || defined(PROTO)
6957 * Convert all backslashes in fname to forward slashes in-place.
6959 void
6960 forward_slash(fname)
6961 char_u *fname;
6963 char_u *p;
6965 for (p = fname; *p != NUL; ++p)
6966 # ifdef FEAT_MBYTE
6967 /* The Big5 encoding can have '\' in the trail byte. */
6968 if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
6969 ++p;
6970 else
6971 # endif
6972 if (*p == '\\')
6973 *p = '/';
6975 #endif
6979 * Code for automatic commands.
6981 * Only included when "FEAT_AUTOCMD" has been defined.
6984 #if defined(FEAT_AUTOCMD) || defined(PROTO)
6987 * The autocommands are stored in a list for each event.
6988 * Autocommands for the same pattern, that are consecutive, are joined
6989 * together, to avoid having to match the pattern too often.
6990 * The result is an array of Autopat lists, which point to AutoCmd lists:
6992 * first_autopat[0] --> Autopat.next --> Autopat.next --> NULL
6993 * Autopat.cmds Autopat.cmds
6994 * | |
6995 * V V
6996 * AutoCmd.next AutoCmd.next
6997 * | |
6998 * V V
6999 * AutoCmd.next NULL
7002 * NULL
7004 * first_autopat[1] --> Autopat.next --> NULL
7005 * Autopat.cmds
7008 * AutoCmd.next
7011 * NULL
7012 * etc.
7014 * The order of AutoCmds is important, this is the order in which they were
7015 * defined and will have to be executed.
7017 typedef struct AutoCmd
7019 char_u *cmd; /* The command to be executed (NULL
7020 when command has been removed) */
7021 char nested; /* If autocommands nest here */
7022 char last; /* last command in list */
7023 #ifdef FEAT_EVAL
7024 scid_T scriptID; /* script ID where defined */
7025 #endif
7026 struct AutoCmd *next; /* Next AutoCmd in list */
7027 } AutoCmd;
7029 typedef struct AutoPat
7031 int group; /* group ID */
7032 char_u *pat; /* pattern as typed (NULL when pattern
7033 has been removed) */
7034 int patlen; /* strlen() of pat */
7035 regprog_T *reg_prog; /* compiled regprog for pattern */
7036 char allow_dirs; /* Pattern may match whole path */
7037 char last; /* last pattern for apply_autocmds() */
7038 AutoCmd *cmds; /* list of commands to do */
7039 struct AutoPat *next; /* next AutoPat in AutoPat list */
7040 int buflocal_nr; /* !=0 for buffer-local AutoPat */
7041 } AutoPat;
7043 static struct event_name
7045 char *name; /* event name */
7046 event_T event; /* event number */
7047 } event_names[] =
7049 {"BufAdd", EVENT_BUFADD},
7050 {"BufCreate", EVENT_BUFADD},
7051 {"BufDelete", EVENT_BUFDELETE},
7052 {"BufEnter", EVENT_BUFENTER},
7053 {"BufFilePost", EVENT_BUFFILEPOST},
7054 {"BufFilePre", EVENT_BUFFILEPRE},
7055 {"BufHidden", EVENT_BUFHIDDEN},
7056 {"BufLeave", EVENT_BUFLEAVE},
7057 {"BufNew", EVENT_BUFNEW},
7058 {"BufNewFile", EVENT_BUFNEWFILE},
7059 {"BufRead", EVENT_BUFREADPOST},
7060 {"BufReadCmd", EVENT_BUFREADCMD},
7061 {"BufReadPost", EVENT_BUFREADPOST},
7062 {"BufReadPre", EVENT_BUFREADPRE},
7063 {"BufUnload", EVENT_BUFUNLOAD},
7064 {"BufWinEnter", EVENT_BUFWINENTER},
7065 {"BufWinLeave", EVENT_BUFWINLEAVE},
7066 {"BufWipeout", EVENT_BUFWIPEOUT},
7067 {"BufWrite", EVENT_BUFWRITEPRE},
7068 {"BufWritePost", EVENT_BUFWRITEPOST},
7069 {"BufWritePre", EVENT_BUFWRITEPRE},
7070 {"BufWriteCmd", EVENT_BUFWRITECMD},
7071 {"CmdwinEnter", EVENT_CMDWINENTER},
7072 {"CmdwinLeave", EVENT_CMDWINLEAVE},
7073 {"ColorScheme", EVENT_COLORSCHEME},
7074 {"CursorHold", EVENT_CURSORHOLD},
7075 {"CursorHoldI", EVENT_CURSORHOLDI},
7076 {"CursorMoved", EVENT_CURSORMOVED},
7077 {"CursorMovedI", EVENT_CURSORMOVEDI},
7078 {"EncodingChanged", EVENT_ENCODINGCHANGED},
7079 {"FileEncoding", EVENT_ENCODINGCHANGED},
7080 {"FileAppendPost", EVENT_FILEAPPENDPOST},
7081 {"FileAppendPre", EVENT_FILEAPPENDPRE},
7082 {"FileAppendCmd", EVENT_FILEAPPENDCMD},
7083 {"FileChangedShell",EVENT_FILECHANGEDSHELL},
7084 {"FileChangedShellPost",EVENT_FILECHANGEDSHELLPOST},
7085 {"FileChangedRO", EVENT_FILECHANGEDRO},
7086 {"FileReadPost", EVENT_FILEREADPOST},
7087 {"FileReadPre", EVENT_FILEREADPRE},
7088 {"FileReadCmd", EVENT_FILEREADCMD},
7089 {"FileType", EVENT_FILETYPE},
7090 {"FileWritePost", EVENT_FILEWRITEPOST},
7091 {"FileWritePre", EVENT_FILEWRITEPRE},
7092 {"FileWriteCmd", EVENT_FILEWRITECMD},
7093 {"FilterReadPost", EVENT_FILTERREADPOST},
7094 {"FilterReadPre", EVENT_FILTERREADPRE},
7095 {"FilterWritePost", EVENT_FILTERWRITEPOST},
7096 {"FilterWritePre", EVENT_FILTERWRITEPRE},
7097 {"FocusGained", EVENT_FOCUSGAINED},
7098 {"FocusLost", EVENT_FOCUSLOST},
7099 {"FuncUndefined", EVENT_FUNCUNDEFINED},
7100 {"GUIEnter", EVENT_GUIENTER},
7101 {"GUIFailed", EVENT_GUIFAILED},
7102 {"InsertChange", EVENT_INSERTCHANGE},
7103 {"InsertEnter", EVENT_INSERTENTER},
7104 {"InsertLeave", EVENT_INSERTLEAVE},
7105 {"MenuPopup", EVENT_MENUPOPUP},
7106 {"QuickFixCmdPost", EVENT_QUICKFIXCMDPOST},
7107 {"QuickFixCmdPre", EVENT_QUICKFIXCMDPRE},
7108 {"RemoteReply", EVENT_REMOTEREPLY},
7109 {"SessionLoadPost", EVENT_SESSIONLOADPOST},
7110 {"ShellCmdPost", EVENT_SHELLCMDPOST},
7111 {"ShellFilterPost", EVENT_SHELLFILTERPOST},
7112 {"SourcePre", EVENT_SOURCEPRE},
7113 {"SourceCmd", EVENT_SOURCECMD},
7114 {"SpellFileMissing",EVENT_SPELLFILEMISSING},
7115 {"StdinReadPost", EVENT_STDINREADPOST},
7116 {"StdinReadPre", EVENT_STDINREADPRE},
7117 {"SwapExists", EVENT_SWAPEXISTS},
7118 {"Syntax", EVENT_SYNTAX},
7119 {"TabEnter", EVENT_TABENTER},
7120 {"TabLeave", EVENT_TABLEAVE},
7121 {"TermChanged", EVENT_TERMCHANGED},
7122 {"TermResponse", EVENT_TERMRESPONSE},
7123 {"User", EVENT_USER},
7124 {"VimEnter", EVENT_VIMENTER},
7125 {"VimLeave", EVENT_VIMLEAVE},
7126 {"VimLeavePre", EVENT_VIMLEAVEPRE},
7127 {"WinEnter", EVENT_WINENTER},
7128 {"WinLeave", EVENT_WINLEAVE},
7129 {"VimResized", EVENT_VIMRESIZED},
7130 {NULL, (event_T)0}
7133 static AutoPat *first_autopat[NUM_EVENTS] =
7135 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7136 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7137 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7138 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7139 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
7140 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
7144 * struct used to keep status while executing autocommands for an event.
7146 typedef struct AutoPatCmd
7148 AutoPat *curpat; /* next AutoPat to examine */
7149 AutoCmd *nextcmd; /* next AutoCmd to execute */
7150 int group; /* group being used */
7151 char_u *fname; /* fname to match with */
7152 char_u *sfname; /* sfname to match with */
7153 char_u *tail; /* tail of fname */
7154 event_T event; /* current event */
7155 int arg_bufnr; /* initially equal to <abuf>, set to zero when
7156 buf is deleted */
7157 struct AutoPatCmd *next; /* chain of active apc-s for auto-invalidation*/
7158 } AutoPatCmd;
7160 static AutoPatCmd *active_apc_list = NULL; /* stack of active autocommands */
7163 * augroups stores a list of autocmd group names.
7165 static garray_T augroups = {0, 0, sizeof(char_u *), 10, NULL};
7166 #define AUGROUP_NAME(i) (((char_u **)augroups.ga_data)[i])
7169 * The ID of the current group. Group 0 is the default one.
7171 static int current_augroup = AUGROUP_DEFAULT;
7173 static int au_need_clean = FALSE; /* need to delete marked patterns */
7175 static void show_autocmd __ARGS((AutoPat *ap, event_T event));
7176 static void au_remove_pat __ARGS((AutoPat *ap));
7177 static void au_remove_cmds __ARGS((AutoPat *ap));
7178 static void au_cleanup __ARGS((void));
7179 static int au_new_group __ARGS((char_u *name));
7180 static void au_del_group __ARGS((char_u *name));
7181 static event_T event_name2nr __ARGS((char_u *start, char_u **end));
7182 static char_u *event_nr2name __ARGS((event_T event));
7183 static char_u *find_end_event __ARGS((char_u *arg, int have_group));
7184 static int event_ignored __ARGS((event_T event));
7185 static int au_get_grouparg __ARGS((char_u **argp));
7186 static int do_autocmd_event __ARGS((event_T event, char_u *pat, int nested, char_u *cmd, int forceit, int group));
7187 static char_u *getnextac __ARGS((int c, void *cookie, int indent));
7188 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));
7189 static void auto_next_pat __ARGS((AutoPatCmd *apc, int stop_at_last));
7192 static event_T last_event;
7193 static int last_group;
7194 static int autocmd_blocked = 0; /* block all autocmds */
7197 * Show the autocommands for one AutoPat.
7199 static void
7200 show_autocmd(ap, event)
7201 AutoPat *ap;
7202 event_T event;
7204 AutoCmd *ac;
7206 /* Check for "got_int" (here and at various places below), which is set
7207 * when "q" has been hit for the "--more--" prompt */
7208 if (got_int)
7209 return;
7210 if (ap->pat == NULL) /* pattern has been removed */
7211 return;
7213 msg_putchar('\n');
7214 if (got_int)
7215 return;
7216 if (event != last_event || ap->group != last_group)
7218 if (ap->group != AUGROUP_DEFAULT)
7220 if (AUGROUP_NAME(ap->group) == NULL)
7221 msg_puts_attr((char_u *)_("--Deleted--"), hl_attr(HLF_E));
7222 else
7223 msg_puts_attr(AUGROUP_NAME(ap->group), hl_attr(HLF_T));
7224 msg_puts((char_u *)" ");
7226 msg_puts_attr(event_nr2name(event), hl_attr(HLF_T));
7227 last_event = event;
7228 last_group = ap->group;
7229 msg_putchar('\n');
7230 if (got_int)
7231 return;
7233 msg_col = 4;
7234 msg_outtrans(ap->pat);
7236 for (ac = ap->cmds; ac != NULL; ac = ac->next)
7238 if (ac->cmd != NULL) /* skip removed commands */
7240 if (msg_col >= 14)
7241 msg_putchar('\n');
7242 msg_col = 14;
7243 if (got_int)
7244 return;
7245 msg_outtrans(ac->cmd);
7246 #ifdef FEAT_EVAL
7247 if (p_verbose > 0)
7248 last_set_msg(ac->scriptID);
7249 #endif
7250 if (got_int)
7251 return;
7252 if (ac->next != NULL)
7254 msg_putchar('\n');
7255 if (got_int)
7256 return;
7263 * Mark an autocommand pattern for deletion.
7265 static void
7266 au_remove_pat(ap)
7267 AutoPat *ap;
7269 vim_free(ap->pat);
7270 ap->pat = NULL;
7271 ap->buflocal_nr = -1;
7272 au_need_clean = TRUE;
7276 * Mark all commands for a pattern for deletion.
7278 static void
7279 au_remove_cmds(ap)
7280 AutoPat *ap;
7282 AutoCmd *ac;
7284 for (ac = ap->cmds; ac != NULL; ac = ac->next)
7286 vim_free(ac->cmd);
7287 ac->cmd = NULL;
7289 au_need_clean = TRUE;
7293 * Cleanup autocommands and patterns that have been deleted.
7294 * This is only done when not executing autocommands.
7296 static void
7297 au_cleanup()
7299 AutoPat *ap, **prev_ap;
7300 AutoCmd *ac, **prev_ac;
7301 event_T event;
7303 if (autocmd_busy || !au_need_clean)
7304 return;
7306 /* loop over all events */
7307 for (event = (event_T)0; (int)event < (int)NUM_EVENTS;
7308 event = (event_T)((int)event + 1))
7310 /* loop over all autocommand patterns */
7311 prev_ap = &(first_autopat[(int)event]);
7312 for (ap = *prev_ap; ap != NULL; ap = *prev_ap)
7314 /* loop over all commands for this pattern */
7315 prev_ac = &(ap->cmds);
7316 for (ac = *prev_ac; ac != NULL; ac = *prev_ac)
7318 /* remove the command if the pattern is to be deleted or when
7319 * the command has been marked for deletion */
7320 if (ap->pat == NULL || ac->cmd == NULL)
7322 *prev_ac = ac->next;
7323 vim_free(ac->cmd);
7324 vim_free(ac);
7326 else
7327 prev_ac = &(ac->next);
7330 /* remove the pattern if it has been marked for deletion */
7331 if (ap->pat == NULL)
7333 *prev_ap = ap->next;
7334 vim_free(ap->reg_prog);
7335 vim_free(ap);
7337 else
7338 prev_ap = &(ap->next);
7342 au_need_clean = FALSE;
7346 * Called when buffer is freed, to remove/invalidate related buffer-local
7347 * autocmds.
7349 void
7350 aubuflocal_remove(buf)
7351 buf_T *buf;
7353 AutoPat *ap;
7354 event_T event;
7355 AutoPatCmd *apc;
7357 /* invalidate currently executing autocommands */
7358 for (apc = active_apc_list; apc; apc = apc->next)
7359 if (buf->b_fnum == apc->arg_bufnr)
7360 apc->arg_bufnr = 0;
7362 /* invalidate buflocals looping through events */
7363 for (event = (event_T)0; (int)event < (int)NUM_EVENTS;
7364 event = (event_T)((int)event + 1))
7365 /* loop over all autocommand patterns */
7366 for (ap = first_autopat[(int)event]; ap != NULL; ap = ap->next)
7367 if (ap->buflocal_nr == buf->b_fnum)
7369 au_remove_pat(ap);
7370 if (p_verbose >= 6)
7372 verbose_enter();
7373 smsg((char_u *)
7374 _("auto-removing autocommand: %s <buffer=%d>"),
7375 event_nr2name(event), buf->b_fnum);
7376 verbose_leave();
7379 au_cleanup();
7383 * Add an autocmd group name.
7384 * Return it's ID. Returns AUGROUP_ERROR (< 0) for error.
7386 static int
7387 au_new_group(name)
7388 char_u *name;
7390 int i;
7392 i = au_find_group(name);
7393 if (i == AUGROUP_ERROR) /* the group doesn't exist yet, add it */
7395 /* First try using a free entry. */
7396 for (i = 0; i < augroups.ga_len; ++i)
7397 if (AUGROUP_NAME(i) == NULL)
7398 break;
7399 if (i == augroups.ga_len && ga_grow(&augroups, 1) == FAIL)
7400 return AUGROUP_ERROR;
7402 AUGROUP_NAME(i) = vim_strsave(name);
7403 if (AUGROUP_NAME(i) == NULL)
7404 return AUGROUP_ERROR;
7405 if (i == augroups.ga_len)
7406 ++augroups.ga_len;
7409 return i;
7412 static void
7413 au_del_group(name)
7414 char_u *name;
7416 int i;
7418 i = au_find_group(name);
7419 if (i == AUGROUP_ERROR) /* the group doesn't exist */
7420 EMSG2(_("E367: No such group: \"%s\""), name);
7421 else
7423 vim_free(AUGROUP_NAME(i));
7424 AUGROUP_NAME(i) = NULL;
7429 * Find the ID of an autocmd group name.
7430 * Return it's ID. Returns AUGROUP_ERROR (< 0) for error.
7432 static int
7433 au_find_group(name)
7434 char_u *name;
7436 int i;
7438 for (i = 0; i < augroups.ga_len; ++i)
7439 if (AUGROUP_NAME(i) != NULL && STRCMP(AUGROUP_NAME(i), name) == 0)
7440 return i;
7441 return AUGROUP_ERROR;
7445 * Return TRUE if augroup "name" exists.
7448 au_has_group(name)
7449 char_u *name;
7451 return au_find_group(name) != AUGROUP_ERROR;
7455 * ":augroup {name}".
7457 void
7458 do_augroup(arg, del_group)
7459 char_u *arg;
7460 int del_group;
7462 int i;
7464 if (del_group)
7466 if (*arg == NUL)
7467 EMSG(_(e_argreq));
7468 else
7469 au_del_group(arg);
7471 else if (STRICMP(arg, "end") == 0) /* ":aug end": back to group 0 */
7472 current_augroup = AUGROUP_DEFAULT;
7473 else if (*arg) /* ":aug xxx": switch to group xxx */
7475 i = au_new_group(arg);
7476 if (i != AUGROUP_ERROR)
7477 current_augroup = i;
7479 else /* ":aug": list the group names */
7481 msg_start();
7482 for (i = 0; i < augroups.ga_len; ++i)
7484 if (AUGROUP_NAME(i) != NULL)
7486 msg_puts(AUGROUP_NAME(i));
7487 msg_puts((char_u *)" ");
7490 msg_clr_eos();
7491 msg_end();
7495 #if defined(EXITFREE) || defined(PROTO)
7496 void
7497 free_all_autocmds()
7499 for (current_augroup = -1; current_augroup < augroups.ga_len;
7500 ++current_augroup)
7501 do_autocmd((char_u *)"", TRUE);
7502 ga_clear_strings(&augroups);
7504 #endif
7507 * Return the event number for event name "start".
7508 * Return NUM_EVENTS if the event name was not found.
7509 * Return a pointer to the next event name in "end".
7511 static event_T
7512 event_name2nr(start, end)
7513 char_u *start;
7514 char_u **end;
7516 char_u *p;
7517 int i;
7518 int len;
7520 /* the event name ends with end of line, a blank or a comma */
7521 for (p = start; *p && !vim_iswhite(*p) && *p != ','; ++p)
7523 for (i = 0; event_names[i].name != NULL; ++i)
7525 len = (int)STRLEN(event_names[i].name);
7526 if (len == p - start && STRNICMP(event_names[i].name, start, len) == 0)
7527 break;
7529 if (*p == ',')
7530 ++p;
7531 *end = p;
7532 if (event_names[i].name == NULL)
7533 return NUM_EVENTS;
7534 return event_names[i].event;
7538 * Return the name for event "event".
7540 static char_u *
7541 event_nr2name(event)
7542 event_T event;
7544 int i;
7546 for (i = 0; event_names[i].name != NULL; ++i)
7547 if (event_names[i].event == event)
7548 return (char_u *)event_names[i].name;
7549 return (char_u *)"Unknown";
7553 * Scan over the events. "*" stands for all events.
7555 static char_u *
7556 find_end_event(arg, have_group)
7557 char_u *arg;
7558 int have_group; /* TRUE when group name was found */
7560 char_u *pat;
7561 char_u *p;
7563 if (*arg == '*')
7565 if (arg[1] && !vim_iswhite(arg[1]))
7567 EMSG2(_("E215: Illegal character after *: %s"), arg);
7568 return NULL;
7570 pat = arg + 1;
7572 else
7574 for (pat = arg; *pat && !vim_iswhite(*pat); pat = p)
7576 if ((int)event_name2nr(pat, &p) >= (int)NUM_EVENTS)
7578 if (have_group)
7579 EMSG2(_("E216: No such event: %s"), pat);
7580 else
7581 EMSG2(_("E216: No such group or event: %s"), pat);
7582 return NULL;
7586 return pat;
7590 * Return TRUE if "event" is included in 'eventignore'.
7592 static int
7593 event_ignored(event)
7594 event_T event;
7596 char_u *p = p_ei;
7598 while (*p != NUL)
7600 if (STRNICMP(p, "all", 3) == 0 && (p[3] == NUL || p[3] == ','))
7601 return TRUE;
7602 if (event_name2nr(p, &p) == event)
7603 return TRUE;
7606 return FALSE;
7610 * Return OK when the contents of p_ei is valid, FAIL otherwise.
7613 check_ei()
7615 char_u *p = p_ei;
7617 while (*p)
7619 if (STRNICMP(p, "all", 3) == 0 && (p[3] == NUL || p[3] == ','))
7621 p += 3;
7622 if (*p == ',')
7623 ++p;
7625 else if (event_name2nr(p, &p) == NUM_EVENTS)
7626 return FAIL;
7629 return OK;
7632 # if defined(FEAT_SYN_HL) || defined(PROTO)
7635 * Add "what" to 'eventignore' to skip loading syntax highlighting for every
7636 * buffer loaded into the window. "what" must start with a comma.
7637 * Returns the old value of 'eventignore' in allocated memory.
7639 char_u *
7640 au_event_disable(what)
7641 char *what;
7643 char_u *new_ei;
7644 char_u *save_ei;
7646 save_ei = vim_strsave(p_ei);
7647 if (save_ei != NULL)
7649 new_ei = vim_strnsave(p_ei, (int)(STRLEN(p_ei) + STRLEN(what)));
7650 if (new_ei != NULL)
7652 STRCAT(new_ei, what);
7653 set_string_option_direct((char_u *)"ei", -1, new_ei,
7654 OPT_FREE, SID_NONE);
7655 vim_free(new_ei);
7658 return save_ei;
7661 void
7662 au_event_restore(old_ei)
7663 char_u *old_ei;
7665 if (old_ei != NULL)
7667 set_string_option_direct((char_u *)"ei", -1, old_ei,
7668 OPT_FREE, SID_NONE);
7669 vim_free(old_ei);
7672 # endif /* FEAT_SYN_HL */
7675 * do_autocmd() -- implements the :autocmd command. Can be used in the
7676 * following ways:
7678 * :autocmd <event> <pat> <cmd> Add <cmd> to the list of commands that
7679 * will be automatically executed for <event>
7680 * when editing a file matching <pat>, in
7681 * the current group.
7682 * :autocmd <event> <pat> Show the auto-commands associated with
7683 * <event> and <pat>.
7684 * :autocmd <event> Show the auto-commands associated with
7685 * <event>.
7686 * :autocmd Show all auto-commands.
7687 * :autocmd! <event> <pat> <cmd> Remove all auto-commands associated with
7688 * <event> and <pat>, and add the command
7689 * <cmd>, for the current group.
7690 * :autocmd! <event> <pat> Remove all auto-commands associated with
7691 * <event> and <pat> for the current group.
7692 * :autocmd! <event> Remove all auto-commands associated with
7693 * <event> for the current group.
7694 * :autocmd! Remove ALL auto-commands for the current
7695 * group.
7697 * Multiple events and patterns may be given separated by commas. Here are
7698 * some examples:
7699 * :autocmd bufread,bufenter *.c,*.h set tw=0 smartindent noic
7700 * :autocmd bufleave * set tw=79 nosmartindent ic infercase
7702 * :autocmd * *.c show all autocommands for *.c files.
7704 * Mostly a {group} argument can optionally appear before <event>.
7706 void
7707 do_autocmd(arg, forceit)
7708 char_u *arg;
7709 int forceit;
7711 char_u *pat;
7712 char_u *envpat = NULL;
7713 char_u *cmd;
7714 event_T event;
7715 int need_free = FALSE;
7716 int nested = FALSE;
7717 int group;
7720 * Check for a legal group name. If not, use AUGROUP_ALL.
7722 group = au_get_grouparg(&arg);
7723 if (arg == NULL) /* out of memory */
7724 return;
7727 * Scan over the events.
7728 * If we find an illegal name, return here, don't do anything.
7730 pat = find_end_event(arg, group != AUGROUP_ALL);
7731 if (pat == NULL)
7732 return;
7735 * Scan over the pattern. Put a NUL at the end.
7737 pat = skipwhite(pat);
7738 cmd = pat;
7739 while (*cmd && (!vim_iswhite(*cmd) || cmd[-1] == '\\'))
7740 cmd++;
7741 if (*cmd)
7742 *cmd++ = NUL;
7744 /* Expand environment variables in the pattern. Set 'shellslash', we want
7745 * forward slashes here. */
7746 if (vim_strchr(pat, '$') != NULL || vim_strchr(pat, '~') != NULL)
7748 #ifdef BACKSLASH_IN_FILENAME
7749 int p_ssl_save = p_ssl;
7751 p_ssl = TRUE;
7752 #endif
7753 envpat = expand_env_save(pat);
7754 #ifdef BACKSLASH_IN_FILENAME
7755 p_ssl = p_ssl_save;
7756 #endif
7757 if (envpat != NULL)
7758 pat = envpat;
7762 * Check for "nested" flag.
7764 cmd = skipwhite(cmd);
7765 if (*cmd != NUL && STRNCMP(cmd, "nested", 6) == 0 && vim_iswhite(cmd[6]))
7767 nested = TRUE;
7768 cmd = skipwhite(cmd + 6);
7772 * Find the start of the commands.
7773 * Expand <sfile> in it.
7775 if (*cmd != NUL)
7777 cmd = expand_sfile(cmd);
7778 if (cmd == NULL) /* some error */
7779 return;
7780 need_free = TRUE;
7784 * Print header when showing autocommands.
7786 if (!forceit && *cmd == NUL)
7788 /* Highlight title */
7789 MSG_PUTS_TITLE(_("\n--- Auto-Commands ---"));
7793 * Loop over the events.
7795 last_event = (event_T)-1; /* for listing the event name */
7796 last_group = AUGROUP_ERROR; /* for listing the group name */
7797 if (*arg == '*' || *arg == NUL)
7799 for (event = (event_T)0; (int)event < (int)NUM_EVENTS;
7800 event = (event_T)((int)event + 1))
7801 if (do_autocmd_event(event, pat,
7802 nested, cmd, forceit, group) == FAIL)
7803 break;
7805 else
7807 while (*arg && !vim_iswhite(*arg))
7808 if (do_autocmd_event(event_name2nr(arg, &arg), pat,
7809 nested, cmd, forceit, group) == FAIL)
7810 break;
7813 if (need_free)
7814 vim_free(cmd);
7815 vim_free(envpat);
7819 * Find the group ID in a ":autocmd" or ":doautocmd" argument.
7820 * The "argp" argument is advanced to the following argument.
7822 * Returns the group ID, AUGROUP_ERROR for error (out of memory).
7824 static int
7825 au_get_grouparg(argp)
7826 char_u **argp;
7828 char_u *group_name;
7829 char_u *p;
7830 char_u *arg = *argp;
7831 int group = AUGROUP_ALL;
7833 p = skiptowhite(arg);
7834 if (p > arg)
7836 group_name = vim_strnsave(arg, (int)(p - arg));
7837 if (group_name == NULL) /* out of memory */
7838 return AUGROUP_ERROR;
7839 group = au_find_group(group_name);
7840 if (group == AUGROUP_ERROR)
7841 group = AUGROUP_ALL; /* no match, use all groups */
7842 else
7843 *argp = skipwhite(p); /* match, skip over group name */
7844 vim_free(group_name);
7846 return group;
7850 * do_autocmd() for one event.
7851 * If *pat == NUL do for all patterns.
7852 * If *cmd == NUL show entries.
7853 * If forceit == TRUE delete entries.
7854 * If group is not AUGROUP_ALL, only use this group.
7856 static int
7857 do_autocmd_event(event, pat, nested, cmd, forceit, group)
7858 event_T event;
7859 char_u *pat;
7860 int nested;
7861 char_u *cmd;
7862 int forceit;
7863 int group;
7865 AutoPat *ap;
7866 AutoPat **prev_ap;
7867 AutoCmd *ac;
7868 AutoCmd **prev_ac;
7869 int brace_level;
7870 char_u *endpat;
7871 int findgroup;
7872 int allgroups;
7873 int patlen;
7874 int is_buflocal;
7875 int buflocal_nr;
7876 char_u buflocal_pat[25]; /* for "<buffer=X>" */
7878 if (group == AUGROUP_ALL)
7879 findgroup = current_augroup;
7880 else
7881 findgroup = group;
7882 allgroups = (group == AUGROUP_ALL && !forceit && *cmd == NUL);
7885 * Show or delete all patterns for an event.
7887 if (*pat == NUL)
7889 for (ap = first_autopat[(int)event]; ap != NULL; ap = ap->next)
7891 if (forceit) /* delete the AutoPat, if it's in the current group */
7893 if (ap->group == findgroup)
7894 au_remove_pat(ap);
7896 else if (group == AUGROUP_ALL || ap->group == group)
7897 show_autocmd(ap, event);
7902 * Loop through all the specified patterns.
7904 for ( ; *pat; pat = (*endpat == ',' ? endpat + 1 : endpat))
7907 * Find end of the pattern.
7908 * Watch out for a comma in braces, like "*.\{obj,o\}".
7910 brace_level = 0;
7911 for (endpat = pat; *endpat && (*endpat != ',' || brace_level
7912 || endpat[-1] == '\\'); ++endpat)
7914 if (*endpat == '{')
7915 brace_level++;
7916 else if (*endpat == '}')
7917 brace_level--;
7919 if (pat == endpat) /* ignore single comma */
7920 continue;
7921 patlen = (int)(endpat - pat);
7924 * detect special <buflocal[=X]> buffer-local patterns
7926 is_buflocal = FALSE;
7927 buflocal_nr = 0;
7929 if (patlen >= 7 && STRNCMP(pat, "<buffer", 7) == 0
7930 && pat[patlen - 1] == '>')
7932 /* Error will be printed only for addition. printing and removing
7933 * will proceed silently. */
7934 is_buflocal = TRUE;
7935 if (patlen == 8)
7936 buflocal_nr = curbuf->b_fnum;
7937 else if (patlen > 9 && pat[7] == '=')
7939 /* <buffer=abuf> */
7940 if (patlen == 13 && STRNICMP(pat, "<buffer=abuf>", 13))
7941 buflocal_nr = autocmd_bufnr;
7942 /* <buffer=123> */
7943 else if (skipdigits(pat + 8) == pat + patlen - 1)
7944 buflocal_nr = atoi((char *)pat + 8);
7948 if (is_buflocal)
7950 /* normalize pat into standard "<buffer>#N" form */
7951 sprintf((char *)buflocal_pat, "<buffer=%d>", buflocal_nr);
7952 pat = buflocal_pat; /* can modify pat and patlen */
7953 patlen = (int)STRLEN(buflocal_pat); /* but not endpat */
7957 * Find AutoPat entries with this pattern.
7959 prev_ap = &first_autopat[(int)event];
7960 while ((ap = *prev_ap) != NULL)
7962 if (ap->pat != NULL)
7964 /* Accept a pattern when:
7965 * - a group was specified and it's that group, or a group was
7966 * not specified and it's the current group, or a group was
7967 * not specified and we are listing
7968 * - the length of the pattern matches
7969 * - the pattern matches.
7970 * For <buffer[=X]>, this condition works because we normalize
7971 * all buffer-local patterns.
7973 if ((allgroups || ap->group == findgroup)
7974 && ap->patlen == patlen
7975 && STRNCMP(pat, ap->pat, patlen) == 0)
7978 * Remove existing autocommands.
7979 * If adding any new autocmd's for this AutoPat, don't
7980 * delete the pattern from the autopat list, append to
7981 * this list.
7983 if (forceit)
7985 if (*cmd != NUL && ap->next == NULL)
7987 au_remove_cmds(ap);
7988 break;
7990 au_remove_pat(ap);
7994 * Show autocmd's for this autopat, or buflocals <buffer=X>
7996 else if (*cmd == NUL)
7997 show_autocmd(ap, event);
8000 * Add autocmd to this autopat, if it's the last one.
8002 else if (ap->next == NULL)
8003 break;
8006 prev_ap = &ap->next;
8010 * Add a new command.
8012 if (*cmd != NUL)
8015 * If the pattern we want to add a command to does appear at the
8016 * end of the list (or not is not in the list at all), add the
8017 * pattern at the end of the list.
8019 if (ap == NULL)
8021 /* refuse to add buffer-local ap if buffer number is invalid */
8022 if (is_buflocal && (buflocal_nr == 0
8023 || buflist_findnr(buflocal_nr) == NULL))
8025 EMSGN(_("E680: <buffer=%d>: invalid buffer number "),
8026 buflocal_nr);
8027 return FAIL;
8030 ap = (AutoPat *)alloc((unsigned)sizeof(AutoPat));
8031 if (ap == NULL)
8032 return FAIL;
8033 ap->pat = vim_strnsave(pat, patlen);
8034 ap->patlen = patlen;
8035 if (ap->pat == NULL)
8037 vim_free(ap);
8038 return FAIL;
8041 if (is_buflocal)
8043 ap->buflocal_nr = buflocal_nr;
8044 ap->reg_prog = NULL;
8046 else
8048 char_u *reg_pat;
8050 ap->buflocal_nr = 0;
8051 reg_pat = file_pat_to_reg_pat(pat, endpat,
8052 &ap->allow_dirs, TRUE);
8053 if (reg_pat != NULL)
8054 ap->reg_prog = vim_regcomp(reg_pat, RE_MAGIC);
8055 vim_free(reg_pat);
8056 if (reg_pat == NULL || ap->reg_prog == NULL)
8058 vim_free(ap->pat);
8059 vim_free(ap);
8060 return FAIL;
8063 ap->cmds = NULL;
8064 *prev_ap = ap;
8065 ap->next = NULL;
8066 if (group == AUGROUP_ALL)
8067 ap->group = current_augroup;
8068 else
8069 ap->group = group;
8073 * Add the autocmd at the end of the AutoCmd list.
8075 prev_ac = &(ap->cmds);
8076 while ((ac = *prev_ac) != NULL)
8077 prev_ac = &ac->next;
8078 ac = (AutoCmd *)alloc((unsigned)sizeof(AutoCmd));
8079 if (ac == NULL)
8080 return FAIL;
8081 ac->cmd = vim_strsave(cmd);
8082 #ifdef FEAT_EVAL
8083 ac->scriptID = current_SID;
8084 #endif
8085 if (ac->cmd == NULL)
8087 vim_free(ac);
8088 return FAIL;
8090 ac->next = NULL;
8091 *prev_ac = ac;
8092 ac->nested = nested;
8096 au_cleanup(); /* may really delete removed patterns/commands now */
8097 return OK;
8101 * Implementation of ":doautocmd [group] event [fname]".
8102 * Return OK for success, FAIL for failure;
8105 do_doautocmd(arg, do_msg)
8106 char_u *arg;
8107 int do_msg; /* give message for no matching autocmds? */
8109 char_u *fname;
8110 int nothing_done = TRUE;
8111 int group;
8114 * Check for a legal group name. If not, use AUGROUP_ALL.
8116 group = au_get_grouparg(&arg);
8117 if (arg == NULL) /* out of memory */
8118 return FAIL;
8120 if (*arg == '*')
8122 EMSG(_("E217: Can't execute autocommands for ALL events"));
8123 return FAIL;
8127 * Scan over the events.
8128 * If we find an illegal name, return here, don't do anything.
8130 fname = find_end_event(arg, group != AUGROUP_ALL);
8131 if (fname == NULL)
8132 return FAIL;
8134 fname = skipwhite(fname);
8137 * Loop over the events.
8139 while (*arg && !vim_iswhite(*arg))
8140 if (apply_autocmds_group(event_name2nr(arg, &arg),
8141 fname, NULL, TRUE, group, curbuf, NULL))
8142 nothing_done = FALSE;
8144 if (nothing_done && do_msg)
8145 MSG(_("No matching autocommands"));
8147 #ifdef FEAT_EVAL
8148 return aborting() ? FAIL : OK;
8149 #else
8150 return OK;
8151 #endif
8155 * ":doautoall": execute autocommands for each loaded buffer.
8157 void
8158 ex_doautoall(eap)
8159 exarg_T *eap;
8161 int retval;
8162 aco_save_T aco;
8163 buf_T *buf;
8166 * This is a bit tricky: For some commands curwin->w_buffer needs to be
8167 * equal to curbuf, but for some buffers there may not be a window.
8168 * So we change the buffer for the current window for a moment. This
8169 * gives problems when the autocommands make changes to the list of
8170 * buffers or windows...
8172 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
8174 if (curbuf->b_ml.ml_mfp != NULL)
8176 /* find a window for this buffer and save some values */
8177 aucmd_prepbuf(&aco, buf);
8179 /* execute the autocommands for this buffer */
8180 retval = do_doautocmd(eap->arg, FALSE);
8182 /* Execute the modeline settings, but don't set window-local
8183 * options if we are using the current window for another buffer. */
8184 do_modelines(aco.save_curwin == NULL ? OPT_NOWIN : 0);
8186 /* restore the current window */
8187 aucmd_restbuf(&aco);
8189 /* stop if there is some error or buffer was deleted */
8190 if (retval == FAIL || !buf_valid(buf))
8191 break;
8195 check_cursor(); /* just in case lines got deleted */
8199 * Prepare for executing autocommands for (hidden) buffer "buf".
8200 * Search a window for the current buffer. Save the cursor position and
8201 * screen offset.
8202 * Set "curbuf" and "curwin" to match "buf".
8203 * When FEAT_AUTOCMD is not defined another version is used, see below.
8205 void
8206 aucmd_prepbuf(aco, buf)
8207 aco_save_T *aco; /* structure to save values in */
8208 buf_T *buf; /* new curbuf */
8210 win_T *win;
8212 aco->new_curbuf = buf;
8214 /* Find a window that is for the new buffer */
8215 if (buf == curbuf) /* be quick when buf is curbuf */
8216 win = curwin;
8217 else
8218 #ifdef FEAT_WINDOWS
8219 for (win = firstwin; win != NULL; win = win->w_next)
8220 if (win->w_buffer == buf)
8221 break;
8222 #else
8223 win = NULL;
8224 #endif
8227 * Prefer to use an existing window for the buffer, it has the least side
8228 * effects (esp. if "buf" is curbuf).
8229 * Otherwise, use curwin for "buf". It might make some items in the
8230 * window invalid. At least save the cursor and topline.
8232 if (win != NULL)
8234 /* there is a window for "buf", make it the curwin */
8235 aco->save_curwin = curwin;
8236 curwin = win;
8237 aco->save_buf = win->w_buffer;
8238 aco->new_curwin = win;
8240 else
8242 /* there is no window for "buf", use curwin */
8243 aco->save_curwin = NULL;
8244 aco->save_buf = curbuf;
8245 --curbuf->b_nwindows;
8246 curwin->w_buffer = buf;
8247 ++buf->b_nwindows;
8249 /* save cursor and topline, set them to safe values */
8250 aco->save_cursor = curwin->w_cursor;
8251 curwin->w_cursor.lnum = 1;
8252 curwin->w_cursor.col = 0;
8253 aco->save_topline = curwin->w_topline;
8254 curwin->w_topline = 1;
8255 #ifdef FEAT_DIFF
8256 aco->save_topfill = curwin->w_topfill;
8257 curwin->w_topfill = 0;
8258 #endif
8261 curbuf = buf;
8265 * Cleanup after executing autocommands for a (hidden) buffer.
8266 * Restore the window as it was (if possible).
8267 * When FEAT_AUTOCMD is not defined another version is used, see below.
8269 void
8270 aucmd_restbuf(aco)
8271 aco_save_T *aco; /* structure holding saved values */
8273 if (aco->save_curwin != NULL)
8275 /* restore curwin */
8276 #ifdef FEAT_WINDOWS
8277 if (win_valid(aco->save_curwin))
8278 #endif
8280 /* restore the buffer which was previously edited by curwin, if
8281 * it's still the same window and it's valid */
8282 if (curwin == aco->new_curwin
8283 && buf_valid(aco->save_buf)
8284 && aco->save_buf->b_ml.ml_mfp != NULL)
8286 --curbuf->b_nwindows;
8287 curbuf = aco->save_buf;
8288 curwin->w_buffer = curbuf;
8289 ++curbuf->b_nwindows;
8292 curwin = aco->save_curwin;
8293 curbuf = curwin->w_buffer;
8296 else
8298 /* restore buffer for curwin if it still exists and is loaded */
8299 if (buf_valid(aco->save_buf) && aco->save_buf->b_ml.ml_mfp != NULL)
8301 --curbuf->b_nwindows;
8302 curbuf = aco->save_buf;
8303 curwin->w_buffer = curbuf;
8304 ++curbuf->b_nwindows;
8305 curwin->w_cursor = aco->save_cursor;
8306 check_cursor();
8307 /* check topline < line_count, in case lines got deleted */
8308 if (aco->save_topline <= curbuf->b_ml.ml_line_count)
8310 curwin->w_topline = aco->save_topline;
8311 #ifdef FEAT_DIFF
8312 curwin->w_topfill = aco->save_topfill;
8313 #endif
8315 else
8317 curwin->w_topline = curbuf->b_ml.ml_line_count;
8318 #ifdef FEAT_DIFF
8319 curwin->w_topfill = 0;
8320 #endif
8326 static int autocmd_nested = FALSE;
8329 * Execute autocommands for "event" and file name "fname".
8330 * Return TRUE if some commands were executed.
8333 apply_autocmds(event, fname, fname_io, force, buf)
8334 event_T event;
8335 char_u *fname; /* NULL or empty means use actual file name */
8336 char_u *fname_io; /* fname to use for <afile> on cmdline */
8337 int force; /* when TRUE, ignore autocmd_busy */
8338 buf_T *buf; /* buffer for <abuf> */
8340 return apply_autocmds_group(event, fname, fname_io, force,
8341 AUGROUP_ALL, buf, NULL);
8345 * Like apply_autocmds(), but with extra "eap" argument. This takes care of
8346 * setting v:filearg.
8348 static int
8349 apply_autocmds_exarg(event, fname, fname_io, force, buf, eap)
8350 event_T event;
8351 char_u *fname;
8352 char_u *fname_io;
8353 int force;
8354 buf_T *buf;
8355 exarg_T *eap;
8357 return apply_autocmds_group(event, fname, fname_io, force,
8358 AUGROUP_ALL, buf, eap);
8362 * Like apply_autocmds(), but handles the caller's retval. If the script
8363 * processing is being aborted or if retval is FAIL when inside a try
8364 * conditional, no autocommands are executed. If otherwise the autocommands
8365 * cause the script to be aborted, retval is set to FAIL.
8368 apply_autocmds_retval(event, fname, fname_io, force, buf, retval)
8369 event_T event;
8370 char_u *fname; /* NULL or empty means use actual file name */
8371 char_u *fname_io; /* fname to use for <afile> on cmdline */
8372 int force; /* when TRUE, ignore autocmd_busy */
8373 buf_T *buf; /* buffer for <abuf> */
8374 int *retval; /* pointer to caller's retval */
8376 int did_cmd;
8378 #ifdef FEAT_EVAL
8379 if (should_abort(*retval))
8380 return FALSE;
8381 #endif
8383 did_cmd = apply_autocmds_group(event, fname, fname_io, force,
8384 AUGROUP_ALL, buf, NULL);
8385 if (did_cmd
8386 #ifdef FEAT_EVAL
8387 && aborting()
8388 #endif
8390 *retval = FAIL;
8391 return did_cmd;
8395 * Return TRUE when there is a CursorHold autocommand defined.
8398 has_cursorhold()
8400 return (first_autopat[(int)(get_real_state() == NORMAL_BUSY
8401 ? EVENT_CURSORHOLD : EVENT_CURSORHOLDI)] != NULL);
8405 * Return TRUE if the CursorHold event can be triggered.
8408 trigger_cursorhold()
8410 int state;
8412 if (!did_cursorhold && has_cursorhold() && !Recording
8413 #ifdef FEAT_INS_EXPAND
8414 && !ins_compl_active()
8415 #endif
8418 state = get_real_state();
8419 if (state == NORMAL_BUSY || (state & INSERT) != 0)
8420 return TRUE;
8422 return FALSE;
8426 * Return TRUE when there is a CursorMoved autocommand defined.
8429 has_cursormoved()
8431 return (first_autopat[(int)EVENT_CURSORMOVED] != NULL);
8435 * Return TRUE when there is a CursorMovedI autocommand defined.
8438 has_cursormovedI()
8440 return (first_autopat[(int)EVENT_CURSORMOVEDI] != NULL);
8443 static int
8444 apply_autocmds_group(event, fname, fname_io, force, group, buf, eap)
8445 event_T event;
8446 char_u *fname; /* NULL or empty means use actual file name */
8447 char_u *fname_io; /* fname to use for <afile> on cmdline, NULL means
8448 use fname */
8449 int force; /* when TRUE, ignore autocmd_busy */
8450 int group; /* group ID, or AUGROUP_ALL */
8451 buf_T *buf; /* buffer for <abuf> */
8452 exarg_T *eap; /* command arguments */
8454 char_u *sfname = NULL; /* short file name */
8455 char_u *tail;
8456 int save_changed;
8457 buf_T *old_curbuf;
8458 int retval = FALSE;
8459 char_u *save_sourcing_name;
8460 linenr_T save_sourcing_lnum;
8461 char_u *save_autocmd_fname;
8462 int save_autocmd_bufnr;
8463 char_u *save_autocmd_match;
8464 int save_autocmd_busy;
8465 int save_autocmd_nested;
8466 static int nesting = 0;
8467 AutoPatCmd patcmd;
8468 AutoPat *ap;
8469 #ifdef FEAT_EVAL
8470 scid_T save_current_SID;
8471 void *save_funccalp;
8472 char_u *save_cmdarg;
8473 long save_cmdbang;
8474 #endif
8475 static int filechangeshell_busy = FALSE;
8476 #ifdef FEAT_PROFILE
8477 proftime_T wait_time;
8478 #endif
8481 * Quickly return if there are no autocommands for this event or
8482 * autocommands are blocked.
8484 if (first_autopat[(int)event] == NULL || autocmd_blocked > 0)
8485 goto BYPASS_AU;
8488 * When autocommands are busy, new autocommands are only executed when
8489 * explicitly enabled with the "nested" flag.
8491 if (autocmd_busy && !(force || autocmd_nested))
8492 goto BYPASS_AU;
8494 #ifdef FEAT_EVAL
8496 * Quickly return when immediately aborting on error, or when an interrupt
8497 * occurred or an exception was thrown but not caught.
8499 if (aborting())
8500 goto BYPASS_AU;
8501 #endif
8504 * FileChangedShell never nests, because it can create an endless loop.
8506 if (filechangeshell_busy && (event == EVENT_FILECHANGEDSHELL
8507 || event == EVENT_FILECHANGEDSHELLPOST))
8508 goto BYPASS_AU;
8511 * Ignore events in 'eventignore'.
8513 if (event_ignored(event))
8514 goto BYPASS_AU;
8517 * Allow nesting of autocommands, but restrict the depth, because it's
8518 * possible to create an endless loop.
8520 if (nesting == 10)
8522 EMSG(_("E218: autocommand nesting too deep"));
8523 goto BYPASS_AU;
8527 * Check if these autocommands are disabled. Used when doing ":all" or
8528 * ":ball".
8530 if ( (autocmd_no_enter
8531 && (event == EVENT_WINENTER || event == EVENT_BUFENTER))
8532 || (autocmd_no_leave
8533 && (event == EVENT_WINLEAVE || event == EVENT_BUFLEAVE)))
8534 goto BYPASS_AU;
8537 * Save the autocmd_* variables and info about the current buffer.
8539 save_autocmd_fname = autocmd_fname;
8540 save_autocmd_bufnr = autocmd_bufnr;
8541 save_autocmd_match = autocmd_match;
8542 save_autocmd_busy = autocmd_busy;
8543 save_autocmd_nested = autocmd_nested;
8544 save_changed = curbuf->b_changed;
8545 old_curbuf = curbuf;
8548 * Set the file name to be used for <afile>.
8550 if (fname_io == NULL)
8552 if (fname != NULL && *fname != NUL)
8553 autocmd_fname = fname;
8554 else if (buf != NULL)
8555 autocmd_fname = buf->b_fname;
8556 else
8557 autocmd_fname = NULL;
8559 else
8560 autocmd_fname = fname_io;
8563 * Set the buffer number to be used for <abuf>.
8565 if (buf == NULL)
8566 autocmd_bufnr = 0;
8567 else
8568 autocmd_bufnr = buf->b_fnum;
8571 * When the file name is NULL or empty, use the file name of buffer "buf".
8572 * Always use the full path of the file name to match with, in case
8573 * "allow_dirs" is set.
8575 if (fname == NULL || *fname == NUL)
8577 if (buf == NULL)
8578 fname = NULL;
8579 else
8581 #ifdef FEAT_SYN_HL
8582 if (event == EVENT_SYNTAX)
8583 fname = buf->b_p_syn;
8584 else
8585 #endif
8586 if (event == EVENT_FILETYPE)
8587 fname = buf->b_p_ft;
8588 else
8590 if (buf->b_sfname != NULL)
8591 sfname = vim_strsave(buf->b_sfname);
8592 fname = buf->b_ffname;
8595 if (fname == NULL)
8596 fname = (char_u *)"";
8597 fname = vim_strsave(fname); /* make a copy, so we can change it */
8599 else
8601 sfname = vim_strsave(fname);
8602 /* Don't try expanding FileType, Syntax, WindowID or QuickFixCmd* */
8603 if (event == EVENT_FILETYPE
8604 || event == EVENT_SYNTAX
8605 || event == EVENT_REMOTEREPLY
8606 || event == EVENT_SPELLFILEMISSING
8607 || event == EVENT_QUICKFIXCMDPRE
8608 || event == EVENT_QUICKFIXCMDPOST)
8609 fname = vim_strsave(fname);
8610 else
8611 fname = FullName_save(fname, FALSE);
8613 if (fname == NULL) /* out of memory */
8615 vim_free(sfname);
8616 retval = FALSE;
8617 goto BYPASS_AU;
8620 #ifdef BACKSLASH_IN_FILENAME
8622 * Replace all backslashes with forward slashes. This makes the
8623 * autocommand patterns portable between Unix and MS-DOS.
8625 if (sfname != NULL)
8626 forward_slash(sfname);
8627 forward_slash(fname);
8628 #endif
8630 #ifdef VMS
8631 /* remove version for correct match */
8632 if (sfname != NULL)
8633 vms_remove_version(sfname);
8634 vms_remove_version(fname);
8635 #endif
8638 * Set the name to be used for <amatch>.
8640 autocmd_match = fname;
8643 /* Don't redraw while doing auto commands. */
8644 ++RedrawingDisabled;
8645 save_sourcing_name = sourcing_name;
8646 sourcing_name = NULL; /* don't free this one */
8647 save_sourcing_lnum = sourcing_lnum;
8648 sourcing_lnum = 0; /* no line number here */
8650 #ifdef FEAT_EVAL
8651 save_current_SID = current_SID;
8653 # ifdef FEAT_PROFILE
8654 if (do_profiling == PROF_YES)
8655 prof_child_enter(&wait_time); /* doesn't count for the caller itself */
8656 # endif
8658 /* Don't use local function variables, if called from a function */
8659 save_funccalp = save_funccal();
8660 #endif
8663 * When starting to execute autocommands, save the search patterns.
8665 if (!autocmd_busy)
8667 save_search_patterns();
8668 saveRedobuff();
8669 did_filetype = keep_filetype;
8673 * Note that we are applying autocmds. Some commands need to know.
8675 autocmd_busy = TRUE;
8676 filechangeshell_busy = (event == EVENT_FILECHANGEDSHELL);
8677 ++nesting; /* see matching decrement below */
8679 /* Remember that FileType was triggered. Used for did_filetype(). */
8680 if (event == EVENT_FILETYPE)
8681 did_filetype = TRUE;
8683 tail = gettail(fname);
8685 /* Find first autocommand that matches */
8686 patcmd.curpat = first_autopat[(int)event];
8687 patcmd.nextcmd = NULL;
8688 patcmd.group = group;
8689 patcmd.fname = fname;
8690 patcmd.sfname = sfname;
8691 patcmd.tail = tail;
8692 patcmd.event = event;
8693 patcmd.arg_bufnr = autocmd_bufnr;
8694 patcmd.next = NULL;
8695 auto_next_pat(&patcmd, FALSE);
8697 /* found one, start executing the autocommands */
8698 if (patcmd.curpat != NULL)
8700 /* add to active_apc_list */
8701 patcmd.next = active_apc_list;
8702 active_apc_list = &patcmd;
8704 #ifdef FEAT_EVAL
8705 /* set v:cmdarg (only when there is a matching pattern) */
8706 save_cmdbang = get_vim_var_nr(VV_CMDBANG);
8707 if (eap != NULL)
8709 save_cmdarg = set_cmdarg(eap, NULL);
8710 set_vim_var_nr(VV_CMDBANG, (long)eap->forceit);
8712 else
8713 save_cmdarg = NULL; /* avoid gcc warning */
8714 #endif
8715 retval = TRUE;
8716 /* mark the last pattern, to avoid an endless loop when more patterns
8717 * are added when executing autocommands */
8718 for (ap = patcmd.curpat; ap->next != NULL; ap = ap->next)
8719 ap->last = FALSE;
8720 ap->last = TRUE;
8721 check_lnums(TRUE); /* make sure cursor and topline are valid */
8722 do_cmdline(NULL, getnextac, (void *)&patcmd,
8723 DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT);
8724 #ifdef FEAT_EVAL
8725 if (eap != NULL)
8727 (void)set_cmdarg(NULL, save_cmdarg);
8728 set_vim_var_nr(VV_CMDBANG, save_cmdbang);
8730 #endif
8731 /* delete from active_apc_list */
8732 if (active_apc_list == &patcmd) /* just in case */
8733 active_apc_list = patcmd.next;
8736 --RedrawingDisabled;
8737 autocmd_busy = save_autocmd_busy;
8738 filechangeshell_busy = FALSE;
8739 autocmd_nested = save_autocmd_nested;
8740 vim_free(sourcing_name);
8741 sourcing_name = save_sourcing_name;
8742 sourcing_lnum = save_sourcing_lnum;
8743 autocmd_fname = save_autocmd_fname;
8744 autocmd_bufnr = save_autocmd_bufnr;
8745 autocmd_match = save_autocmd_match;
8746 #ifdef FEAT_EVAL
8747 current_SID = save_current_SID;
8748 restore_funccal(save_funccalp);
8749 # ifdef FEAT_PROFILE
8750 if (do_profiling == PROF_YES)
8751 prof_child_exit(&wait_time);
8752 # endif
8753 #endif
8754 vim_free(fname);
8755 vim_free(sfname);
8756 --nesting; /* see matching increment above */
8759 * When stopping to execute autocommands, restore the search patterns and
8760 * the redo buffer.
8762 if (!autocmd_busy)
8764 restore_search_patterns();
8765 restoreRedobuff();
8766 did_filetype = FALSE;
8770 * Some events don't set or reset the Changed flag.
8771 * Check if still in the same buffer!
8773 if (curbuf == old_curbuf
8774 && (event == EVENT_BUFREADPOST
8775 || event == EVENT_BUFWRITEPOST
8776 || event == EVENT_FILEAPPENDPOST
8777 || event == EVENT_VIMLEAVE
8778 || event == EVENT_VIMLEAVEPRE))
8780 #ifdef FEAT_TITLE
8781 if (curbuf->b_changed != save_changed)
8782 need_maketitle = TRUE;
8783 #endif
8784 curbuf->b_changed = save_changed;
8787 au_cleanup(); /* may really delete removed patterns/commands now */
8789 BYPASS_AU:
8790 /* When wiping out a buffer make sure all its buffer-local autocommands
8791 * are deleted. */
8792 if (event == EVENT_BUFWIPEOUT && buf != NULL)
8793 aubuflocal_remove(buf);
8795 return retval;
8798 # ifdef FEAT_EVAL
8799 static char_u *old_termresponse = NULL;
8800 # endif
8803 * Block triggering autocommands until unblock_autocmd() is called.
8804 * Can be used recursively, so long as it's symmetric.
8806 void
8807 block_autocmds()
8809 # ifdef FEAT_EVAL
8810 /* Remember the value of v:termresponse. */
8811 if (autocmd_blocked == 0)
8812 old_termresponse = get_vim_var_str(VV_TERMRESPONSE);
8813 # endif
8814 ++autocmd_blocked;
8817 void
8818 unblock_autocmds()
8820 --autocmd_blocked;
8822 # ifdef FEAT_EVAL
8823 /* When v:termresponse was set while autocommands were blocked, trigger
8824 * the autocommands now. Esp. useful when executing a shell command
8825 * during startup (vimdiff). */
8826 if (autocmd_blocked == 0
8827 && get_vim_var_str(VV_TERMRESPONSE) != old_termresponse)
8828 apply_autocmds(EVENT_TERMRESPONSE, NULL, NULL, FALSE, curbuf);
8829 # endif
8833 * Find next autocommand pattern that matches.
8835 static void
8836 auto_next_pat(apc, stop_at_last)
8837 AutoPatCmd *apc;
8838 int stop_at_last; /* stop when 'last' flag is set */
8840 AutoPat *ap;
8841 AutoCmd *cp;
8842 char_u *name;
8843 char *s;
8845 vim_free(sourcing_name);
8846 sourcing_name = NULL;
8848 for (ap = apc->curpat; ap != NULL && !got_int; ap = ap->next)
8850 apc->curpat = NULL;
8852 /* only use a pattern when it has not been removed, has commands and
8853 * the group matches. For buffer-local autocommands only check the
8854 * buffer number. */
8855 if (ap->pat != NULL && ap->cmds != NULL
8856 && (apc->group == AUGROUP_ALL || apc->group == ap->group))
8858 /* execution-condition */
8859 if (ap->buflocal_nr == 0
8860 ? (match_file_pat(NULL, ap->reg_prog, apc->fname,
8861 apc->sfname, apc->tail, ap->allow_dirs))
8862 : ap->buflocal_nr == apc->arg_bufnr)
8864 name = event_nr2name(apc->event);
8865 s = _("%s Auto commands for \"%s\"");
8866 sourcing_name = alloc((unsigned)(STRLEN(s)
8867 + STRLEN(name) + ap->patlen + 1));
8868 if (sourcing_name != NULL)
8870 sprintf((char *)sourcing_name, s,
8871 (char *)name, (char *)ap->pat);
8872 if (p_verbose >= 8)
8874 verbose_enter();
8875 smsg((char_u *)_("Executing %s"), sourcing_name);
8876 verbose_leave();
8880 apc->curpat = ap;
8881 apc->nextcmd = ap->cmds;
8882 /* mark last command */
8883 for (cp = ap->cmds; cp->next != NULL; cp = cp->next)
8884 cp->last = FALSE;
8885 cp->last = TRUE;
8887 line_breakcheck();
8888 if (apc->curpat != NULL) /* found a match */
8889 break;
8891 if (stop_at_last && ap->last)
8892 break;
8897 * Get next autocommand command.
8898 * Called by do_cmdline() to get the next line for ":if".
8899 * Returns allocated string, or NULL for end of autocommands.
8901 /* ARGSUSED */
8902 static char_u *
8903 getnextac(c, cookie, indent)
8904 int c; /* not used */
8905 void *cookie;
8906 int indent; /* not used */
8908 AutoPatCmd *acp = (AutoPatCmd *)cookie;
8909 char_u *retval;
8910 AutoCmd *ac;
8912 /* Can be called again after returning the last line. */
8913 if (acp->curpat == NULL)
8914 return NULL;
8916 /* repeat until we find an autocommand to execute */
8917 for (;;)
8919 /* skip removed commands */
8920 while (acp->nextcmd != NULL && acp->nextcmd->cmd == NULL)
8921 if (acp->nextcmd->last)
8922 acp->nextcmd = NULL;
8923 else
8924 acp->nextcmd = acp->nextcmd->next;
8926 if (acp->nextcmd != NULL)
8927 break;
8929 /* at end of commands, find next pattern that matches */
8930 if (acp->curpat->last)
8931 acp->curpat = NULL;
8932 else
8933 acp->curpat = acp->curpat->next;
8934 if (acp->curpat != NULL)
8935 auto_next_pat(acp, TRUE);
8936 if (acp->curpat == NULL)
8937 return NULL;
8940 ac = acp->nextcmd;
8942 if (p_verbose >= 9)
8944 verbose_enter_scroll();
8945 smsg((char_u *)_("autocommand %s"), ac->cmd);
8946 msg_puts((char_u *)"\n"); /* don't overwrite this either */
8947 verbose_leave_scroll();
8949 retval = vim_strsave(ac->cmd);
8950 autocmd_nested = ac->nested;
8951 #ifdef FEAT_EVAL
8952 current_SID = ac->scriptID;
8953 #endif
8954 if (ac->last)
8955 acp->nextcmd = NULL;
8956 else
8957 acp->nextcmd = ac->next;
8958 return retval;
8962 * Return TRUE if there is a matching autocommand for "fname".
8963 * To account for buffer-local autocommands, function needs to know
8964 * in which buffer the file will be opened.
8967 has_autocmd(event, sfname, buf)
8968 event_T event;
8969 char_u *sfname;
8970 buf_T *buf;
8972 AutoPat *ap;
8973 char_u *fname;
8974 char_u *tail = gettail(sfname);
8975 int retval = FALSE;
8977 fname = FullName_save(sfname, FALSE);
8978 if (fname == NULL)
8979 return FALSE;
8981 #ifdef BACKSLASH_IN_FILENAME
8983 * Replace all backslashes with forward slashes. This makes the
8984 * autocommand patterns portable between Unix and MS-DOS.
8986 sfname = vim_strsave(sfname);
8987 if (sfname != NULL)
8988 forward_slash(sfname);
8989 forward_slash(fname);
8990 #endif
8992 for (ap = first_autopat[(int)event]; ap != NULL; ap = ap->next)
8993 if (ap->pat != NULL && ap->cmds != NULL
8994 && (ap->buflocal_nr == 0
8995 ? match_file_pat(NULL, ap->reg_prog,
8996 fname, sfname, tail, ap->allow_dirs)
8997 : buf != NULL && ap->buflocal_nr == buf->b_fnum
9000 retval = TRUE;
9001 break;
9004 vim_free(fname);
9005 #ifdef BACKSLASH_IN_FILENAME
9006 vim_free(sfname);
9007 #endif
9009 return retval;
9012 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
9014 * Function given to ExpandGeneric() to obtain the list of autocommand group
9015 * names.
9017 /*ARGSUSED*/
9018 char_u *
9019 get_augroup_name(xp, idx)
9020 expand_T *xp;
9021 int idx;
9023 if (idx == augroups.ga_len) /* add "END" add the end */
9024 return (char_u *)"END";
9025 if (idx >= augroups.ga_len) /* end of list */
9026 return NULL;
9027 if (AUGROUP_NAME(idx) == NULL) /* skip deleted entries */
9028 return (char_u *)"";
9029 return AUGROUP_NAME(idx); /* return a name */
9032 static int include_groups = FALSE;
9034 char_u *
9035 set_context_in_autocmd(xp, arg, doautocmd)
9036 expand_T *xp;
9037 char_u *arg;
9038 int doautocmd; /* TRUE for :doautocmd, FALSE for :autocmd */
9040 char_u *p;
9041 int group;
9043 /* check for a group name, skip it if present */
9044 include_groups = FALSE;
9045 p = arg;
9046 group = au_get_grouparg(&arg);
9047 if (group == AUGROUP_ERROR)
9048 return NULL;
9049 /* If there only is a group name that's what we expand. */
9050 if (*arg == NUL && group != AUGROUP_ALL && !vim_iswhite(arg[-1]))
9052 arg = p;
9053 group = AUGROUP_ALL;
9056 /* skip over event name */
9057 for (p = arg; *p != NUL && !vim_iswhite(*p); ++p)
9058 if (*p == ',')
9059 arg = p + 1;
9060 if (*p == NUL)
9062 if (group == AUGROUP_ALL)
9063 include_groups = TRUE;
9064 xp->xp_context = EXPAND_EVENTS; /* expand event name */
9065 xp->xp_pattern = arg;
9066 return NULL;
9069 /* skip over pattern */
9070 arg = skipwhite(p);
9071 while (*arg && (!vim_iswhite(*arg) || arg[-1] == '\\'))
9072 arg++;
9073 if (*arg)
9074 return arg; /* expand (next) command */
9076 if (doautocmd)
9077 xp->xp_context = EXPAND_FILES; /* expand file names */
9078 else
9079 xp->xp_context = EXPAND_NOTHING; /* pattern is not expanded */
9080 return NULL;
9084 * Function given to ExpandGeneric() to obtain the list of event names.
9086 /*ARGSUSED*/
9087 char_u *
9088 get_event_name(xp, idx)
9089 expand_T *xp;
9090 int idx;
9092 if (idx < augroups.ga_len) /* First list group names, if wanted */
9094 if (!include_groups || AUGROUP_NAME(idx) == NULL)
9095 return (char_u *)""; /* skip deleted entries */
9096 return AUGROUP_NAME(idx); /* return a name */
9098 return (char_u *)event_names[idx - augroups.ga_len].name;
9101 #endif /* FEAT_CMDL_COMPL */
9104 * Return TRUE if autocmd is supported.
9107 autocmd_supported(name)
9108 char_u *name;
9110 char_u *p;
9112 return (event_name2nr(name, &p) != NUM_EVENTS);
9116 * Return TRUE if an autocommand is defined for a group, event and
9117 * pattern: The group can be omitted to accept any group. "event" and "pattern"
9118 * can be NULL to accept any event and pattern. "pattern" can be NULL to accept
9119 * any pattern. Buffer-local patterns <buffer> or <buffer=N> are accepted.
9120 * Used for:
9121 * exists("#Group") or
9122 * exists("#Group#Event") or
9123 * exists("#Group#Event#pat") or
9124 * exists("#Event") or
9125 * exists("#Event#pat")
9128 au_exists(arg)
9129 char_u *arg;
9131 char_u *arg_save;
9132 char_u *pattern = NULL;
9133 char_u *event_name;
9134 char_u *p;
9135 event_T event;
9136 AutoPat *ap;
9137 buf_T *buflocal_buf = NULL;
9138 int group;
9139 int retval = FALSE;
9141 /* Make a copy so that we can change the '#' chars to a NUL. */
9142 arg_save = vim_strsave(arg);
9143 if (arg_save == NULL)
9144 return FALSE;
9145 p = vim_strchr(arg_save, '#');
9146 if (p != NULL)
9147 *p++ = NUL;
9149 /* First, look for an autocmd group name */
9150 group = au_find_group(arg_save);
9151 if (group == AUGROUP_ERROR)
9153 /* Didn't match a group name, assume the first argument is an event. */
9154 group = AUGROUP_ALL;
9155 event_name = arg_save;
9157 else
9159 if (p == NULL)
9161 /* "Group": group name is present and it's recognized */
9162 retval = TRUE;
9163 goto theend;
9166 /* Must be "Group#Event" or "Group#Event#pat". */
9167 event_name = p;
9168 p = vim_strchr(event_name, '#');
9169 if (p != NULL)
9170 *p++ = NUL; /* "Group#Event#pat" */
9173 pattern = p; /* "pattern" is NULL when there is no pattern */
9175 /* find the index (enum) for the event name */
9176 event = event_name2nr(event_name, &p);
9178 /* return FALSE if the event name is not recognized */
9179 if (event == NUM_EVENTS)
9180 goto theend;
9182 /* Find the first autocommand for this event.
9183 * If there isn't any, return FALSE;
9184 * If there is one and no pattern given, return TRUE; */
9185 ap = first_autopat[(int)event];
9186 if (ap == NULL)
9187 goto theend;
9188 if (pattern == NULL)
9190 retval = TRUE;
9191 goto theend;
9194 /* if pattern is "<buffer>", special handling is needed which uses curbuf */
9195 /* for pattern "<buffer=N>, fnamecmp() will work fine */
9196 if (STRICMP(pattern, "<buffer>") == 0)
9197 buflocal_buf = curbuf;
9199 /* Check if there is an autocommand with the given pattern. */
9200 for ( ; ap != NULL; ap = ap->next)
9201 /* only use a pattern when it has not been removed and has commands. */
9202 /* For buffer-local autocommands, fnamecmp() works fine. */
9203 if (ap->pat != NULL && ap->cmds != NULL
9204 && (group == AUGROUP_ALL || ap->group == group)
9205 && (buflocal_buf == NULL
9206 ? fnamecmp(ap->pat, pattern) == 0
9207 : ap->buflocal_nr == buflocal_buf->b_fnum))
9209 retval = TRUE;
9210 break;
9213 theend:
9214 vim_free(arg_save);
9215 return retval;
9218 #else /* FEAT_AUTOCMD */
9221 * Prepare for executing commands for (hidden) buffer "buf".
9222 * This is the non-autocommand version, it simply saves "curbuf" and sets
9223 * "curbuf" and "curwin" to match "buf".
9225 void
9226 aucmd_prepbuf(aco, buf)
9227 aco_save_T *aco; /* structure to save values in */
9228 buf_T *buf; /* new curbuf */
9230 aco->save_buf = buf;
9231 curbuf = buf;
9232 curwin->w_buffer = buf;
9236 * Restore after executing commands for a (hidden) buffer.
9237 * This is the non-autocommand version.
9239 void
9240 aucmd_restbuf(aco)
9241 aco_save_T *aco; /* structure holding saved values */
9243 curbuf = aco->save_buf;
9244 curwin->w_buffer = curbuf;
9247 #endif /* FEAT_AUTOCMD */
9250 #if defined(FEAT_AUTOCMD) || defined(FEAT_WILDIGN) || defined(PROTO)
9252 * Try matching a filename with a "pattern" ("prog" is NULL), or use the
9253 * precompiled regprog "prog" ("pattern" is NULL). That avoids calling
9254 * vim_regcomp() often.
9255 * Used for autocommands and 'wildignore'.
9256 * Returns TRUE if there is a match, FALSE otherwise.
9259 match_file_pat(pattern, prog, fname, sfname, tail, allow_dirs)
9260 char_u *pattern; /* pattern to match with */
9261 regprog_T *prog; /* pre-compiled regprog or NULL */
9262 char_u *fname; /* full path of file name */
9263 char_u *sfname; /* short file name or NULL */
9264 char_u *tail; /* tail of path */
9265 int allow_dirs; /* allow matching with dir */
9267 regmatch_T regmatch;
9268 int result = FALSE;
9269 #ifdef FEAT_OSFILETYPE
9270 int no_pattern = FALSE; /* TRUE if check is filetype only */
9271 char_u *type_start;
9272 char_u c;
9273 int match = FALSE;
9274 #endif
9276 #ifdef CASE_INSENSITIVE_FILENAME
9277 regmatch.rm_ic = TRUE; /* Always ignore case */
9278 #else
9279 regmatch.rm_ic = FALSE; /* Don't ever ignore case */
9280 #endif
9281 #ifdef FEAT_OSFILETYPE
9282 if (*pattern == '<')
9284 /* There is a filetype condition specified with this pattern.
9285 * Check the filetype matches first. If not, don't bother with the
9286 * pattern (set regprog to NULL).
9287 * Always use magic for the regexp.
9290 for (type_start = pattern + 1; (c = *pattern); pattern++)
9292 if ((c == ';' || c == '>') && match == FALSE)
9294 *pattern = NUL; /* Terminate the string */
9295 match = mch_check_filetype(fname, type_start);
9296 *pattern = c; /* Restore the terminator */
9297 type_start = pattern + 1;
9299 if (c == '>')
9300 break;
9303 /* (c should never be NUL, but check anyway) */
9304 if (match == FALSE || c == NUL)
9305 regmatch.regprog = NULL; /* Doesn't match - don't check pat. */
9306 else if (*pattern == NUL)
9308 regmatch.regprog = NULL; /* Vim will try to free regprog later */
9309 no_pattern = TRUE; /* Always matches - don't check pat. */
9311 else
9312 regmatch.regprog = vim_regcomp(pattern + 1, RE_MAGIC);
9314 else
9315 #endif
9317 if (prog != NULL)
9318 regmatch.regprog = prog;
9319 else
9320 regmatch.regprog = vim_regcomp(pattern, RE_MAGIC);
9324 * Try for a match with the pattern with:
9325 * 1. the full file name, when the pattern has a '/'.
9326 * 2. the short file name, when the pattern has a '/'.
9327 * 3. the tail of the file name, when the pattern has no '/'.
9329 if (
9330 #ifdef FEAT_OSFILETYPE
9331 /* If the check is for a filetype only and we don't care
9332 * about the path then skip all the regexp stuff.
9334 no_pattern ||
9335 #endif
9336 (regmatch.regprog != NULL
9337 && ((allow_dirs
9338 && (vim_regexec(&regmatch, fname, (colnr_T)0)
9339 || (sfname != NULL
9340 && vim_regexec(&regmatch, sfname, (colnr_T)0))))
9341 || (!allow_dirs && vim_regexec(&regmatch, tail, (colnr_T)0)))))
9342 result = TRUE;
9344 if (prog == NULL)
9345 vim_free(regmatch.regprog);
9346 return result;
9348 #endif
9350 #if defined(FEAT_WILDIGN) || defined(PROTO)
9352 * Return TRUE if a file matches with a pattern in "list".
9353 * "list" is a comma-separated list of patterns, like 'wildignore'.
9354 * "sfname" is the short file name or NULL, "ffname" the long file name.
9357 match_file_list(list, sfname, ffname)
9358 char_u *list;
9359 char_u *sfname;
9360 char_u *ffname;
9362 char_u buf[100];
9363 char_u *tail;
9364 char_u *regpat;
9365 char allow_dirs;
9366 int match;
9367 char_u *p;
9369 tail = gettail(sfname);
9371 /* try all patterns in 'wildignore' */
9372 p = list;
9373 while (*p)
9375 copy_option_part(&p, buf, 100, ",");
9376 regpat = file_pat_to_reg_pat(buf, NULL, &allow_dirs, FALSE);
9377 if (regpat == NULL)
9378 break;
9379 match = match_file_pat(regpat, NULL, ffname, sfname,
9380 tail, (int)allow_dirs);
9381 vim_free(regpat);
9382 if (match)
9383 return TRUE;
9385 return FALSE;
9387 #endif
9390 * Convert the given pattern "pat" which has shell style wildcards in it, into
9391 * a regular expression, and return the result in allocated memory. If there
9392 * is a directory path separator to be matched, then TRUE is put in
9393 * allow_dirs, otherwise FALSE is put there -- webb.
9394 * Handle backslashes before special characters, like "\*" and "\ ".
9396 * If FEAT_OSFILETYPE defined then pass initial <type> through unchanged. Eg:
9397 * '<html>myfile' becomes '<html>^myfile$' -- leonard.
9399 * Returns NULL when out of memory.
9401 /*ARGSUSED*/
9402 char_u *
9403 file_pat_to_reg_pat(pat, pat_end, allow_dirs, no_bslash)
9404 char_u *pat;
9405 char_u *pat_end; /* first char after pattern or NULL */
9406 char *allow_dirs; /* Result passed back out in here */
9407 int no_bslash; /* Don't use a backward slash as pathsep */
9409 int size;
9410 char_u *endp;
9411 char_u *reg_pat;
9412 char_u *p;
9413 int i;
9414 int nested = 0;
9415 int add_dollar = TRUE;
9416 #ifdef FEAT_OSFILETYPE
9417 int check_length = 0;
9418 #endif
9420 if (allow_dirs != NULL)
9421 *allow_dirs = FALSE;
9422 if (pat_end == NULL)
9423 pat_end = pat + STRLEN(pat);
9425 #ifdef FEAT_OSFILETYPE
9426 /* Find out how much of the string is the filetype check */
9427 if (*pat == '<')
9429 /* Count chars until the next '>' */
9430 for (p = pat + 1; p < pat_end && *p != '>'; p++)
9432 if (p < pat_end)
9434 /* Pattern is of the form <.*>.* */
9435 check_length = p - pat + 1;
9436 if (p + 1 >= pat_end)
9438 /* The 'pattern' is a filetype check ONLY */
9439 reg_pat = (char_u *)alloc(check_length + 1);
9440 if (reg_pat != NULL)
9442 mch_memmove(reg_pat, pat, (size_t)check_length);
9443 reg_pat[check_length] = NUL;
9445 return reg_pat;
9448 /* else: there was no closing '>' - assume it was a normal pattern */
9451 pat += check_length;
9452 size = 2 + check_length;
9453 #else
9454 size = 2; /* '^' at start, '$' at end */
9455 #endif
9457 for (p = pat; p < pat_end; p++)
9459 switch (*p)
9461 case '*':
9462 case '.':
9463 case ',':
9464 case '{':
9465 case '}':
9466 case '~':
9467 size += 2; /* extra backslash */
9468 break;
9469 #ifdef BACKSLASH_IN_FILENAME
9470 case '\\':
9471 case '/':
9472 size += 4; /* could become "[\/]" */
9473 break;
9474 #endif
9475 default:
9476 size++;
9477 # ifdef FEAT_MBYTE
9478 if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
9480 ++p;
9481 ++size;
9483 # endif
9484 break;
9487 reg_pat = alloc(size + 1);
9488 if (reg_pat == NULL)
9489 return NULL;
9491 #ifdef FEAT_OSFILETYPE
9492 /* Copy the type check in to the start. */
9493 if (check_length)
9494 mch_memmove(reg_pat, pat - check_length, (size_t)check_length);
9495 i = check_length;
9496 #else
9497 i = 0;
9498 #endif
9500 if (pat[0] == '*')
9501 while (pat[0] == '*' && pat < pat_end - 1)
9502 pat++;
9503 else
9504 reg_pat[i++] = '^';
9505 endp = pat_end - 1;
9506 if (*endp == '*')
9508 while (endp - pat > 0 && *endp == '*')
9509 endp--;
9510 add_dollar = FALSE;
9512 for (p = pat; *p && nested >= 0 && p <= endp; p++)
9514 switch (*p)
9516 case '*':
9517 reg_pat[i++] = '.';
9518 reg_pat[i++] = '*';
9519 while (p[1] == '*') /* "**" matches like "*" */
9520 ++p;
9521 break;
9522 case '.':
9523 #ifdef RISCOS
9524 if (allow_dirs != NULL)
9525 *allow_dirs = TRUE;
9526 /* FALLTHROUGH */
9527 #endif
9528 case '~':
9529 reg_pat[i++] = '\\';
9530 reg_pat[i++] = *p;
9531 break;
9532 case '?':
9533 #ifdef RISCOS
9534 case '#':
9535 #endif
9536 reg_pat[i++] = '.';
9537 break;
9538 case '\\':
9539 if (p[1] == NUL)
9540 break;
9541 #ifdef BACKSLASH_IN_FILENAME
9542 if (!no_bslash)
9544 /* translate:
9545 * "\x" to "\\x" e.g., "dir\file"
9546 * "\*" to "\\.*" e.g., "dir\*.c"
9547 * "\?" to "\\." e.g., "dir\??.c"
9548 * "\+" to "\+" e.g., "fileX\+.c"
9550 if ((vim_isfilec(p[1]) || p[1] == '*' || p[1] == '?')
9551 && p[1] != '+')
9553 reg_pat[i++] = '[';
9554 reg_pat[i++] = '\\';
9555 reg_pat[i++] = '/';
9556 reg_pat[i++] = ']';
9557 if (allow_dirs != NULL)
9558 *allow_dirs = TRUE;
9559 break;
9562 #endif
9563 if (*++p == '?'
9564 #ifdef BACKSLASH_IN_FILENAME
9565 && no_bslash
9566 #endif
9568 reg_pat[i++] = '?';
9569 else
9570 if (*p == ',')
9571 reg_pat[i++] = ',';
9572 else
9574 if (allow_dirs != NULL && vim_ispathsep(*p)
9575 #ifdef BACKSLASH_IN_FILENAME
9576 && (!no_bslash || *p != '\\')
9577 #endif
9579 *allow_dirs = TRUE;
9580 reg_pat[i++] = '\\';
9581 reg_pat[i++] = *p;
9583 break;
9584 #ifdef BACKSLASH_IN_FILENAME
9585 case '/':
9586 reg_pat[i++] = '[';
9587 reg_pat[i++] = '\\';
9588 reg_pat[i++] = '/';
9589 reg_pat[i++] = ']';
9590 if (allow_dirs != NULL)
9591 *allow_dirs = TRUE;
9592 break;
9593 #endif
9594 case '{':
9595 reg_pat[i++] = '\\';
9596 reg_pat[i++] = '(';
9597 nested++;
9598 break;
9599 case '}':
9600 reg_pat[i++] = '\\';
9601 reg_pat[i++] = ')';
9602 --nested;
9603 break;
9604 case ',':
9605 if (nested)
9607 reg_pat[i++] = '\\';
9608 reg_pat[i++] = '|';
9610 else
9611 reg_pat[i++] = ',';
9612 break;
9613 default:
9614 # ifdef FEAT_MBYTE
9615 if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
9616 reg_pat[i++] = *p++;
9617 else
9618 # endif
9619 if (allow_dirs != NULL && vim_ispathsep(*p))
9620 *allow_dirs = TRUE;
9621 reg_pat[i++] = *p;
9622 break;
9625 if (add_dollar)
9626 reg_pat[i++] = '$';
9627 reg_pat[i] = NUL;
9628 if (nested != 0)
9630 if (nested < 0)
9631 EMSG(_("E219: Missing {."));
9632 else
9633 EMSG(_("E220: Missing }."));
9634 vim_free(reg_pat);
9635 reg_pat = NULL;
9637 return reg_pat;