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