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