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