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