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