# HG changeset patch # User Bram Moolenaar # Date 1569681904 -7200 # Node ID e2be5a6485f52d5fc72c36b8b2095b61a06bd5fd # Parent 3ebea66ebaff85e92c04130ca4c0d0434e65f40f patch 8.1.2094: the fileio.c file is too big Commit: https://github.com/vim/vim/commit/473952e85286eb9c6098801f1819981ba61ad153 Author: Bram Moolenaar Date: Sat Sep 28 16:30:04 2019 +0200 patch 8.1.2094: the fileio.c file is too big Problem: The fileio.c file is too big. Solution: Move buf_write() to bufwrite.c. (Yegappan Lakshmanan, closes #4990) diff --git a/Filelist b/Filelist --- a/Filelist +++ b/Filelist @@ -21,6 +21,7 @@ SRC_ALL = \ src/blob.c \ src/blowfish.c \ src/buffer.c \ + src/bufwrite.c \ src/change.c \ src/channel.c \ src/charset.c \ @@ -186,6 +187,7 @@ SRC_ALL = \ src/proto/blob.pro \ src/proto/blowfish.pro \ src/proto/buffer.pro \ + src/proto/bufwrite.pro \ src/proto/change.pro \ src/proto/channel.pro \ src/proto/charset.pro \ diff --git a/src/Make_cyg_ming.mak b/src/Make_cyg_ming.mak --- a/src/Make_cyg_ming.mak +++ b/src/Make_cyg_ming.mak @@ -709,6 +709,7 @@ OBJ = \ $(OUTDIR)/blob.o \ $(OUTDIR)/blowfish.o \ $(OUTDIR)/buffer.o \ + $(OUTDIR)/bufwrite.o \ $(OUTDIR)/change.o \ $(OUTDIR)/charset.o \ $(OUTDIR)/cmdexpand.o \ diff --git a/src/Make_morph.mak b/src/Make_morph.mak --- a/src/Make_morph.mak +++ b/src/Make_morph.mak @@ -29,6 +29,7 @@ SRC = arabic.c \ autocmd.c \ blowfish.c \ buffer.c \ + bufwrite.c \ change.c \ charset.c \ cmdexpand.c \ diff --git a/src/Make_mvc.mak b/src/Make_mvc.mak --- a/src/Make_mvc.mak +++ b/src/Make_mvc.mak @@ -716,6 +716,7 @@ OBJ = \ $(OUTDIR)\blob.obj \ $(OUTDIR)\blowfish.obj \ $(OUTDIR)\buffer.obj \ + $(OUTDIR)\bufwrite.obj \ $(OUTDIR)\change.obj \ $(OUTDIR)\charset.obj \ $(OUTDIR)\cmdexpand.obj \ @@ -1457,6 +1458,8 @@ testclean: $(OUTDIR)/buffer.obj: $(OUTDIR) buffer.c $(INCL) +$(OUTDIR)/bufwrite.obj: $(OUTDIR) bufwrite.c $(INCL) + $(OUTDIR)/change.obj: $(OUTDIR) change.c $(INCL) $(OUTDIR)/charset.obj: $(OUTDIR) charset.c $(INCL) @@ -1788,6 +1791,7 @@ proto.h: \ proto/blob.pro \ proto/blowfish.pro \ proto/buffer.pro \ + proto/bufwrite.pro \ proto/change.pro \ proto/charset.pro \ proto/cmdexpand.pro \ diff --git a/src/Make_vms.mms b/src/Make_vms.mms --- a/src/Make_vms.mms +++ b/src/Make_vms.mms @@ -2,7 +2,7 @@ # Makefile for Vim on OpenVMS # # Maintainer: Zoltan Arpadffy -# Last change: 2019 Sep 27 +# Last change: 2019 Sep 28 # # This has script been tested on VMS 6.2 to 8.2 on DEC Alpha, VAX and IA64 # with MMS and MMK @@ -307,48 +307,210 @@ ALL_CFLAGS_VER = /def=($(MODEL_DEF)$(DEF ALL_LIBS = $(LIBS) $(GUI_LIB_DIR) $(GUI_LIB) \ $(PERL_LIB) $(PYTHON_LIB) $(TCL_LIB) $(RUBY_LIB) -SRC = arabic.c arglist.c autocmd.c beval.c blob.c blowfish.c buffer.c \ - change.c charset.c cmdexpand.c cmdhist.c crypt.c crypt_zip.c \ - debugger.c dict.c diff.c digraph.c drawline.c drawscreen.c edit.c \ - eval.c evalbuffer.c evalfunc.c \ - evalvars.c evalwindow.c ex_cmds.c ex_cmds2.c ex_docmd.c ex_eval.c \ +SRC = \ + arabic.c \ + arglist.c \ + autocmd.c \ + beval.c \ + blob.c \ + blowfish.c \ + buffer.c \ + bufwrite.c \ + change.c \ + charset.c \ + cmdexpand.c \ + cmdhist.c \ + crypt.c \ + crypt_zip.c \ + debugger.c \ + dict.c \ + diff.c \ + digraph.c \ + drawline.c \ + drawscreen.c \ + edit.c \ + eval.c \ + evalbuffer.c \ + evalfunc.c \ + evalvars.c \ + evalwindow.c \ + ex_cmds.c \ + ex_cmds2.c \ + ex_docmd.c \ + ex_eval.c \ ex_getln.c \ - if_cscope.c if_xcmdsrv.c fileio.c filepath.c, findfile.c fold.c \ - getchar.c hardcopy.c hashtab.c highlight.c \ - indent.c insexpand.c json.c list.c main.c map.c mark.c menu.c mbyte.c \ - memfile.c memline.c message.c misc1.c misc2.c mouse.c move.c normal.c \ + fileio.c \ + filepath.c, \ + findfile.c \ + fold.c \ + getchar.c \ + hardcopy.c \ + hashtab.c \ + highlight.c \ + if_cscope.c \ + if_xcmdsrv.c \ + indent.c \ + insexpand.c \ + json.c \ + list.c \ + main.c \ + map.c \ + mark.c \ + mbyte.c \ + memfile.c \ + memline.c \ + menu.c \ + message.c \ + misc1.c \ + misc2.c \ + mouse.c \ + move.c \ + normal.c \ ops.c \ - option.c optionstr.c popupmenu.c popupwin.c profiler.c quickfix.c \ - regexp.c register.c scriptfile.c \ - search.c session.c sha256.c sign.c spell.c spellfile.c spellsuggest.c \ - syntax.c tag.c \ - term.c termlib.c testing.c textprop.c ui.c undo.c usercmd.c \ - userfunc.c version.c viminfo.c screen.c window.c os_unix.c os_vms.c \ + option.c \ + optionstr.c \ + os_unix.c \ + os_vms.c \ pathdef.c \ - $(GUI_SRC) $(PERL_SRC) $(PYTHON_SRC) $(TCL_SRC) \ - $(RUBY_SRC) $(HANGULIN_SRC) $(MZSCH_SRC) $(XDIFF_SRC) + popupmenu.c \ + popupwin.c \ + profiler.c \ + quickfix.c \ + regexp.c \ + register.c \ + screen.c \ + scriptfile.c \ + search.c \ + session.c \ + sha256.c \ + sign.c \ + spell.c \ + spellfile.c \ + spellsuggest.c \ + syntax.c \ + tag.c \ + term.c \ + termlib.c \ + testing.c \ + textprop.c \ + ui.c \ + undo.c \ + usercmd.c \ + userfunc.c \ + version.c \ + viminfo.c \ + window.c \ + $(GUI_SRC) \ + $(PERL_SRC) \ + $(PYTHON_SRC) \ + $(TCL_SRC) \ + $(RUBY_SRC) \ + $(HANGULIN_SRC) \ + $(MZSCH_SRC) \ + $(XDIFF_SRC) -OBJ = arabic.obj arglist.obj autocmd.obj beval.obj blob.obj blowfish.obj \ - buffer.obj change.obj charset.obj cmdexpand.obj cmdhist.obj \ - crypt.obj crypt_zip.obj debugger.obj dict.obj diff.obj digraph.obj \ - drawline.obj drawscreen.obj edit.obj eval.obj evalbuffer.obj \ - evalfunc.obj evalvars.obj evalwindow.obj ex_cmds.obj ex_cmds2.obj \ - ex_docmd.obj ex_eval.obj ex_getln.obj if_cscope.obj if_xcmdsrv.obj \ - fileio.obj filepath.obj \ - findfile.obj fold.obj getchar.obj hardcopy.obj hashtab.obj \ - highlight.obj indent.obj insexpand.obj json.obj list.obj main.obj \ - map.obj mark.obj menu.obj memfile.obj memline.obj message.obj \ - misc1.obj misc2.obj mouse.obj move.obj mbyte.obj normal.obj ops.obj \ +OBJ = \ + arabic.obj \ + arglist.obj \ + autocmd.obj \ + beval.obj \ + blob.obj \ + blowfish.obj \ + buffer.obj \ + bufwrite.obj \ + change.obj \ + charset.obj \ + cmdexpand.obj \ + cmdhist.obj \ + crypt.obj \ + crypt_zip.obj \ + debugger.obj \ + dict.obj \ + diff.obj \ + digraph.obj \ + drawline.obj \ + drawscreen.obj \ + edit.obj \ + eval.obj \ + evalbuffer.obj \ + evalfunc.obj \ + evalvars.obj \ + evalwindow.obj \ + ex_cmds.obj \ + ex_cmds2.obj \ + ex_docmd.obj \ + ex_eval.obj \ + ex_getln.obj \ + fileio.obj \ + filepath.obj \ + findfile.obj \ + fold.obj \ + getchar.obj \ + hardcopy.obj \ + hashtab.obj \ + highlight.obj \ + if_cscope.obj \ + if_mzsch.obj \ + if_xcmdsrv.obj \ + indent.obj \ + insexpand.obj \ + json.obj \ + list.obj \ + main.obj \ + map.obj \ + mark.obj \ + mbyte.obj \ + memfile.obj \ + memline.obj \ + menu.obj \ + message.obj \ + misc1.obj \ + misc2.obj \ + mouse.obj \ + move.obj \ + normal.obj \ + ops.obj \ option.obj \ - optionstr.obj popupmenu.obj popupwin.obj profiler.obj quickfix.obj \ - regexp.obj register.obj scriptfile.obj \ - search.obj session.obj sha256.obj sign.obj spell.obj spellfile.obj \ - spellsuggest.obj syntax.obj tag.obj term.obj termlib.obj testing.obj \ + optionstr.obj \ + os_unix.obj \ + os_vms.obj \ + pathdef.obj \ + popupmenu.obj \ + popupwin.obj \ + profiler.obj \ + quickfix.obj \ + regexp.obj \ + register.obj \ + screen.obj \ + scriptfile.obj \ + search.obj \ + session.obj \ + sha256.obj \ + sign.obj \ + spell.obj \ + spellfile.obj \ + spellsuggest.obj \ + syntax.obj \ + tag.obj \ + term.obj \ + termlib.obj \ + testing.obj \ textprop.obj \ - ui.obj undo.obj usercmd.obj userfunc.obj screen.obj version.obj \ - viminfo.obj window.obj os_unix.obj os_vms.obj pathdef.obj if_mzsch.obj \ - $(GUI_OBJ) $(PERL_OBJ) $(PYTHON_OBJ) $(TCL_OBJ) \ - $(RUBY_OBJ) $(HANGULIN_OBJ) $(MZSCH_OBJ) $(XDIFF_OBJ) + ui.obj \ + undo.obj \ + usercmd.obj \ + userfunc.obj \ + version.obj \ + viminfo.obj \ + window.obj \ + $(GUI_OBJ) \ + $(PERL_OBJ) \ + $(PYTHON_OBJ) \ + $(TCL_OBJ) \ + $(RUBY_OBJ) \ + $(HANGULIN_OBJ) \ + $(MZSCH_OBJ) \ + $(XDIFF_OBJ) # Default target is making the executable all : [.auto]config.h mmk_compat motif_env gtk_env perl_env python_env tcl_env ruby_env $(TARGET) @@ -526,6 +688,10 @@ buffer.obj : buffer.c vim.h [.auto]confi ascii.h keymap.h term.h macros.h structs.h regexp.h \ gui.h beval.h [.proto]gui_beval.pro option.h ex_cmds.h proto.h \ globals.h version.h +bufwrite.obj : bufwrite.c vim.h [.auto]config.h feature.h os_unix.h \ + ascii.h keymap.h term.h macros.h structs.h regexp.h \ + gui.h beval.h [.proto]gui_beval.pro option.h ex_cmds.h proto.h \ + globals.h version.h change.obj : change.c vim.h [.auto]config.h feature.h os_unix.h \ ascii.h keymap.h term.h macros.h structs.h regexp.h \ gui.h beval.h [.proto]gui_beval.pro option.h ex_cmds.h proto.h \ diff --git a/src/Makefile b/src/Makefile --- a/src/Makefile +++ b/src/Makefile @@ -1668,6 +1668,7 @@ BASIC_SRC = \ version.c \ viminfo.c \ window.c \ + bufwrite.c \ $(OS_EXTRA_SRC) SRC = $(BASIC_SRC) \ @@ -1804,6 +1805,7 @@ OBJ_COMMON = \ objects/version.o \ objects/viminfo.o \ objects/window.o \ + objects/bufwrite.o \ $(GUI_OBJ) \ $(TERM_OBJ) \ $(LUA_OBJ) \ @@ -1966,6 +1968,7 @@ PRO_AUTO = \ version.pro \ viminfo.pro \ window.pro \ + bufwrite.pro \ beval.pro \ gui_beval.pro \ netbeans.pro \ @@ -3432,6 +3435,9 @@ objects/viminfo.o: viminfo.c objects/window.o: window.c $(CCC) -o $@ window.c +objects/bufwrite.o: bufwrite.c + $(CCC) -o $@ bufwrite.c + objects/netbeans.o: netbeans.c $(CCC) -o $@ netbeans.c @@ -3949,6 +3955,10 @@ objects/window.o: window.c vim.h protode auto/osdef.h ascii.h keymap.h term.h macros.h option.h beval.h \ proto/gui_beval.pro structs.h regexp.h gui.h alloc.h ex_cmds.h spell.h \ proto.h globals.h +objects/bufwrite.o: bufwrite.c vim.h protodef.h auto/config.h feature.h os_unix.h \ + auto/osdef.h ascii.h keymap.h term.h macros.h option.h beval.h \ + proto/gui_beval.pro structs.h regexp.h gui.h alloc.h ex_cmds.h spell.h \ + proto.h globals.h objects/gui.o: gui.c vim.h protodef.h auto/config.h feature.h os_unix.h \ auto/osdef.h ascii.h keymap.h term.h macros.h option.h beval.h \ proto/gui_beval.pro structs.h regexp.h gui.h alloc.h ex_cmds.h spell.h \ diff --git a/src/README.md b/src/README.md --- a/src/README.md +++ b/src/README.md @@ -27,6 +27,7 @@ arglist.c | handling argument list autocmd.c | autocommands blob.c | blob data type buffer.c | manipulating buffers (loaded files) +bufwrite.c | writing a buffer to file change.c | handling changes to text cmdexpand.c | command-line completion cmdhist.c | command-line history diff --git a/src/bufwrite.c b/src/bufwrite.c new file mode 100644 --- /dev/null +++ b/src/bufwrite.c @@ -0,0 +1,2559 @@ +/* vi:set ts=8 sts=4 sw=4 noet: + * + * VIM - Vi IMproved by Bram Moolenaar + * + * Do ":help uganda" in Vim to read copying and usage conditions. + * Do ":help credits" in Vim to see a list of people who contributed. + * See README.txt for an overview of the Vim source code. + */ + +/* + * bufwrite.c: functions for writing a buffer + */ + +#include "vim.h" + +#if defined(HAVE_UTIME) && defined(HAVE_UTIME_H) +# include // for struct utimbuf +#endif + +#define SMALLBUFSIZE 256 // size of emergency write buffer + +/* + * Structure to pass arguments from buf_write() to buf_write_bytes(). + */ +struct bw_info +{ + int bw_fd; // file descriptor + char_u *bw_buf; // buffer with data to be written + int bw_len; // length of data + int bw_flags; // FIO_ flags +#ifdef FEAT_CRYPT + buf_T *bw_buffer; // buffer being written +#endif + char_u bw_rest[CONV_RESTLEN]; // not converted bytes + int bw_restlen; // nr of bytes in bw_rest[] + int bw_first; // first write call + char_u *bw_conv_buf; // buffer for writing converted chars + size_t bw_conv_buflen; // size of bw_conv_buf + int bw_conv_error; // set for conversion error + linenr_T bw_conv_error_lnum; // first line with error or zero + linenr_T bw_start_lnum; // line number at start of buffer +#ifdef USE_ICONV + iconv_t bw_iconv_fd; // descriptor for iconv() or -1 +#endif +}; + +/* + * Convert a Unicode character to bytes. + * Return TRUE for an error, FALSE when it's OK. + */ + static int +ucs2bytes( + unsigned c, // in: character + char_u **pp, // in/out: pointer to result + int flags) // FIO_ flags +{ + char_u *p = *pp; + int error = FALSE; + int cc; + + + if (flags & FIO_UCS4) + { + if (flags & FIO_ENDIAN_L) + { + *p++ = c; + *p++ = (c >> 8); + *p++ = (c >> 16); + *p++ = (c >> 24); + } + else + { + *p++ = (c >> 24); + *p++ = (c >> 16); + *p++ = (c >> 8); + *p++ = c; + } + } + else if (flags & (FIO_UCS2 | FIO_UTF16)) + { + if (c >= 0x10000) + { + if (flags & FIO_UTF16) + { + // Make two words, ten bits of the character in each. First + // word is 0xd800 - 0xdbff, second one 0xdc00 - 0xdfff + c -= 0x10000; + if (c >= 0x100000) + error = TRUE; + cc = ((c >> 10) & 0x3ff) + 0xd800; + if (flags & FIO_ENDIAN_L) + { + *p++ = cc; + *p++ = ((unsigned)cc >> 8); + } + else + { + *p++ = ((unsigned)cc >> 8); + *p++ = cc; + } + c = (c & 0x3ff) + 0xdc00; + } + else + error = TRUE; + } + if (flags & FIO_ENDIAN_L) + { + *p++ = c; + *p++ = (c >> 8); + } + else + { + *p++ = (c >> 8); + *p++ = c; + } + } + else // Latin1 + { + if (c >= 0x100) + { + error = TRUE; + *p++ = 0xBF; + } + else + *p++ = c; + } + + *pp = p; + return error; +} + +/* + * Call write() to write a number of bytes to the file. + * Handles encryption and 'encoding' conversion. + * + * Return FAIL for failure, OK otherwise. + */ + static int +buf_write_bytes(struct bw_info *ip) +{ + int wlen; + char_u *buf = ip->bw_buf; // data to write + int len = ip->bw_len; // length of data + int flags = ip->bw_flags; // extra flags + + // Skip conversion when writing the crypt magic number or the BOM. + if (!(flags & FIO_NOCONVERT)) + { + char_u *p; + unsigned c; + int n; + + if (flags & FIO_UTF8) + { + // Convert latin1 in the buffer to UTF-8 in the file. + p = ip->bw_conv_buf; // translate to buffer + for (wlen = 0; wlen < len; ++wlen) + p += utf_char2bytes(buf[wlen], p); + buf = ip->bw_conv_buf; + len = (int)(p - ip->bw_conv_buf); + } + else if (flags & (FIO_UCS4 | FIO_UTF16 | FIO_UCS2 | FIO_LATIN1)) + { + // Convert UTF-8 bytes in the buffer to UCS-2, UCS-4, UTF-16 or + // Latin1 chars in the file. + if (flags & FIO_LATIN1) + p = buf; // translate in-place (can only get shorter) + else + p = ip->bw_conv_buf; // translate to buffer + for (wlen = 0; wlen < len; wlen += n) + { + if (wlen == 0 && ip->bw_restlen != 0) + { + int l; + + // Use remainder of previous call. Append the start of + // buf[] to get a full sequence. Might still be too + // short! + l = CONV_RESTLEN - ip->bw_restlen; + if (l > len) + l = len; + mch_memmove(ip->bw_rest + ip->bw_restlen, buf, (size_t)l); + n = utf_ptr2len_len(ip->bw_rest, ip->bw_restlen + l); + if (n > ip->bw_restlen + len) + { + // We have an incomplete byte sequence at the end to + // be written. We can't convert it without the + // remaining bytes. Keep them for the next call. + if (ip->bw_restlen + len > CONV_RESTLEN) + return FAIL; + ip->bw_restlen += len; + break; + } + if (n > 1) + c = utf_ptr2char(ip->bw_rest); + else + c = ip->bw_rest[0]; + if (n >= ip->bw_restlen) + { + n -= ip->bw_restlen; + ip->bw_restlen = 0; + } + else + { + ip->bw_restlen -= n; + mch_memmove(ip->bw_rest, ip->bw_rest + n, + (size_t)ip->bw_restlen); + n = 0; + } + } + else + { + n = utf_ptr2len_len(buf + wlen, len - wlen); + if (n > len - wlen) + { + // We have an incomplete byte sequence at the end to + // be written. We can't convert it without the + // remaining bytes. Keep them for the next call. + if (len - wlen > CONV_RESTLEN) + return FAIL; + ip->bw_restlen = len - wlen; + mch_memmove(ip->bw_rest, buf + wlen, + (size_t)ip->bw_restlen); + break; + } + if (n > 1) + c = utf_ptr2char(buf + wlen); + else + c = buf[wlen]; + } + + if (ucs2bytes(c, &p, flags) && !ip->bw_conv_error) + { + ip->bw_conv_error = TRUE; + ip->bw_conv_error_lnum = ip->bw_start_lnum; + } + if (c == NL) + ++ip->bw_start_lnum; + } + if (flags & FIO_LATIN1) + len = (int)(p - buf); + else + { + buf = ip->bw_conv_buf; + len = (int)(p - ip->bw_conv_buf); + } + } + +#ifdef MSWIN + else if (flags & FIO_CODEPAGE) + { + // Convert UTF-8 or codepage to UCS-2 and then to MS-Windows + // codepage. + char_u *from; + size_t fromlen; + char_u *to; + int u8c; + BOOL bad = FALSE; + int needed; + + if (ip->bw_restlen > 0) + { + // Need to concatenate the remainder of the previous call and + // the bytes of the current call. Use the end of the + // conversion buffer for this. + fromlen = len + ip->bw_restlen; + from = ip->bw_conv_buf + ip->bw_conv_buflen - fromlen; + mch_memmove(from, ip->bw_rest, (size_t)ip->bw_restlen); + mch_memmove(from + ip->bw_restlen, buf, (size_t)len); + } + else + { + from = buf; + fromlen = len; + } + + to = ip->bw_conv_buf; + if (enc_utf8) + { + // Convert from UTF-8 to UCS-2, to the start of the buffer. + // The buffer has been allocated to be big enough. + while (fromlen > 0) + { + n = (int)utf_ptr2len_len(from, (int)fromlen); + if (n > (int)fromlen) // incomplete byte sequence + break; + u8c = utf_ptr2char(from); + *to++ = (u8c & 0xff); + *to++ = (u8c >> 8); + fromlen -= n; + from += n; + } + + // Copy remainder to ip->bw_rest[] to be used for the next + // call. + if (fromlen > CONV_RESTLEN) + { + // weird overlong sequence + ip->bw_conv_error = TRUE; + return FAIL; + } + mch_memmove(ip->bw_rest, from, fromlen); + ip->bw_restlen = (int)fromlen; + } + else + { + // Convert from enc_codepage to UCS-2, to the start of the + // buffer. The buffer has been allocated to be big enough. + ip->bw_restlen = 0; + needed = MultiByteToWideChar(enc_codepage, + MB_ERR_INVALID_CHARS, (LPCSTR)from, (int)fromlen, + NULL, 0); + if (needed == 0) + { + // When conversion fails there may be a trailing byte. + needed = MultiByteToWideChar(enc_codepage, + MB_ERR_INVALID_CHARS, (LPCSTR)from, (int)fromlen - 1, + NULL, 0); + if (needed == 0) + { + // Conversion doesn't work. + ip->bw_conv_error = TRUE; + return FAIL; + } + // Save the trailing byte for the next call. + ip->bw_rest[0] = from[fromlen - 1]; + ip->bw_restlen = 1; + } + needed = MultiByteToWideChar(enc_codepage, MB_ERR_INVALID_CHARS, + (LPCSTR)from, (int)(fromlen - ip->bw_restlen), + (LPWSTR)to, needed); + if (needed == 0) + { + // Safety check: Conversion doesn't work. + ip->bw_conv_error = TRUE; + return FAIL; + } + to += needed * 2; + } + + fromlen = to - ip->bw_conv_buf; + buf = to; +# ifdef CP_UTF8 // VC 4.1 doesn't define CP_UTF8 + if (FIO_GET_CP(flags) == CP_UTF8) + { + // Convert from UCS-2 to UTF-8, using the remainder of the + // conversion buffer. Fails when out of space. + for (from = ip->bw_conv_buf; fromlen > 1; fromlen -= 2) + { + u8c = *from++; + u8c += (*from++ << 8); + to += utf_char2bytes(u8c, to); + if (to + 6 >= ip->bw_conv_buf + ip->bw_conv_buflen) + { + ip->bw_conv_error = TRUE; + return FAIL; + } + } + len = (int)(to - buf); + } + else +# endif + { + // Convert from UCS-2 to the codepage, using the remainder of + // the conversion buffer. If the conversion uses the default + // character "0", the data doesn't fit in this encoding, so + // fail. + len = WideCharToMultiByte(FIO_GET_CP(flags), 0, + (LPCWSTR)ip->bw_conv_buf, (int)fromlen / sizeof(WCHAR), + (LPSTR)to, (int)(ip->bw_conv_buflen - fromlen), 0, + &bad); + if (bad) + { + ip->bw_conv_error = TRUE; + return FAIL; + } + } + } +#endif + +#ifdef MACOS_CONVERT + else if (flags & FIO_MACROMAN) + { + // Convert UTF-8 or latin1 to Apple MacRoman. + char_u *from; + size_t fromlen; + + if (ip->bw_restlen > 0) + { + // Need to concatenate the remainder of the previous call and + // the bytes of the current call. Use the end of the + // conversion buffer for this. + fromlen = len + ip->bw_restlen; + from = ip->bw_conv_buf + ip->bw_conv_buflen - fromlen; + mch_memmove(from, ip->bw_rest, (size_t)ip->bw_restlen); + mch_memmove(from + ip->bw_restlen, buf, (size_t)len); + } + else + { + from = buf; + fromlen = len; + } + + if (enc2macroman(from, fromlen, + ip->bw_conv_buf, &len, ip->bw_conv_buflen, + ip->bw_rest, &ip->bw_restlen) == FAIL) + { + ip->bw_conv_error = TRUE; + return FAIL; + } + buf = ip->bw_conv_buf; + } +#endif + +#ifdef USE_ICONV + if (ip->bw_iconv_fd != (iconv_t)-1) + { + const char *from; + size_t fromlen; + char *to; + size_t tolen; + + // Convert with iconv(). + if (ip->bw_restlen > 0) + { + char *fp; + + // Need to concatenate the remainder of the previous call and + // the bytes of the current call. Use the end of the + // conversion buffer for this. + fromlen = len + ip->bw_restlen; + fp = (char *)ip->bw_conv_buf + ip->bw_conv_buflen - fromlen; + mch_memmove(fp, ip->bw_rest, (size_t)ip->bw_restlen); + mch_memmove(fp + ip->bw_restlen, buf, (size_t)len); + from = fp; + tolen = ip->bw_conv_buflen - fromlen; + } + else + { + from = (const char *)buf; + fromlen = len; + tolen = ip->bw_conv_buflen; + } + to = (char *)ip->bw_conv_buf; + + if (ip->bw_first) + { + size_t save_len = tolen; + + // output the initial shift state sequence + (void)iconv(ip->bw_iconv_fd, NULL, NULL, &to, &tolen); + + // There is a bug in iconv() on Linux (which appears to be + // wide-spread) which sets "to" to NULL and messes up "tolen". + if (to == NULL) + { + to = (char *)ip->bw_conv_buf; + tolen = save_len; + } + ip->bw_first = FALSE; + } + + // If iconv() has an error or there is not enough room, fail. + if ((iconv(ip->bw_iconv_fd, (void *)&from, &fromlen, &to, &tolen) + == (size_t)-1 && ICONV_ERRNO != ICONV_EINVAL) + || fromlen > CONV_RESTLEN) + { + ip->bw_conv_error = TRUE; + return FAIL; + } + + // copy remainder to ip->bw_rest[] to be used for the next call. + if (fromlen > 0) + mch_memmove(ip->bw_rest, (void *)from, fromlen); + ip->bw_restlen = (int)fromlen; + + buf = ip->bw_conv_buf; + len = (int)((char_u *)to - ip->bw_conv_buf); + } +#endif + } + + if (ip->bw_fd < 0) + // Only checking conversion, which is OK if we get here. + return OK; + +#ifdef FEAT_CRYPT + if (flags & FIO_ENCRYPTED) + { + // Encrypt the data. Do it in-place if possible, otherwise use an + // allocated buffer. +# ifdef CRYPT_NOT_INPLACE + if (crypt_works_inplace(ip->bw_buffer->b_cryptstate)) + { +# endif + crypt_encode_inplace(ip->bw_buffer->b_cryptstate, buf, len); +# ifdef CRYPT_NOT_INPLACE + } + else + { + char_u *outbuf; + + len = crypt_encode_alloc(curbuf->b_cryptstate, buf, len, &outbuf); + if (len == 0) + return OK; // Crypt layer is buffering, will flush later. + wlen = write_eintr(ip->bw_fd, outbuf, len); + vim_free(outbuf); + return (wlen < len) ? FAIL : OK; + } +# endif + } +#endif + + wlen = write_eintr(ip->bw_fd, buf, len); + return (wlen < len) ? FAIL : OK; +} + +/* + * Check modification time of file, before writing to it. + * The size isn't checked, because using a tool like "gzip" takes care of + * using the same timestamp but can't set the size. + */ + static int +check_mtime(buf_T *buf, stat_T *st) +{ + if (buf->b_mtime_read != 0 + && time_differs((long)st->st_mtime, buf->b_mtime_read)) + { + msg_scroll = TRUE; // don't overwrite messages here + msg_silent = 0; // must give this prompt + // don't use emsg() here, don't want to flush the buffers + msg_attr(_("WARNING: The file has been changed since reading it!!!"), + HL_ATTR(HLF_E)); + if (ask_yesno((char_u *)_("Do you really want to write to it"), + TRUE) == 'n') + return FAIL; + msg_scroll = FALSE; // always overwrite the file message now + } + return OK; +} + +/* + * Generate a BOM in "buf[4]" for encoding "name". + * Return the length of the BOM (zero when no BOM). + */ + static int +make_bom(char_u *buf, char_u *name) +{ + int flags; + char_u *p; + + flags = get_fio_flags(name); + + // Can't put a BOM in a non-Unicode file. + if (flags == FIO_LATIN1 || flags == 0) + return 0; + + if (flags == FIO_UTF8) // UTF-8 + { + buf[0] = 0xef; + buf[1] = 0xbb; + buf[2] = 0xbf; + return 3; + } + p = buf; + (void)ucs2bytes(0xfeff, &p, flags); + return (int)(p - buf); +} + +#ifdef UNIX + static void +set_file_time( + char_u *fname, + time_t atime, // access time + time_t mtime) // modification time +{ +# if defined(HAVE_UTIME) && defined(HAVE_UTIME_H) + struct utimbuf buf; + + buf.actime = atime; + buf.modtime = mtime; + (void)utime((char *)fname, &buf); +# else +# if defined(HAVE_UTIMES) + struct timeval tvp[2]; + + tvp[0].tv_sec = atime; + tvp[0].tv_usec = 0; + tvp[1].tv_sec = mtime; + tvp[1].tv_usec = 0; +# ifdef NeXT + (void)utimes((char *)fname, tvp); +# else + (void)utimes((char *)fname, (const struct timeval *)&tvp); +# endif +# endif +# endif +} +#endif // UNIX + +/* + * buf_write() - write to file "fname" lines "start" through "end" + * + * We do our own buffering here because fwrite() is so slow. + * + * If "forceit" is true, we don't care for errors when attempting backups. + * In case of an error everything possible is done to restore the original + * file. But when "forceit" is TRUE, we risk losing it. + * + * When "reset_changed" is TRUE and "append" == FALSE and "start" == 1 and + * "end" == curbuf->b_ml.ml_line_count, reset curbuf->b_changed. + * + * This function must NOT use NameBuff (because it's called by autowrite()). + * + * return FAIL for failure, OK otherwise + */ + int +buf_write( + buf_T *buf, + char_u *fname, + char_u *sfname, + linenr_T start, + linenr_T end, + exarg_T *eap, // for forced 'ff' and 'fenc', can be + // NULL! + int append, // append to the file + int forceit, + int reset_changed, + int filtering) +{ + int fd; + char_u *backup = NULL; + int backup_copy = FALSE; // copy the original file? + int dobackup; + char_u *ffname; + char_u *wfname = NULL; // name of file to write to + char_u *s; + char_u *ptr; + char_u c; + int len; + linenr_T lnum; + long nchars; + char_u *errmsg = NULL; + int errmsg_allocated = FALSE; + char_u *errnum = NULL; + char_u *buffer; + char_u smallbuf[SMALLBUFSIZE]; + char_u *backup_ext; + int bufsize; + long perm; // file permissions + int retval = OK; + int newfile = FALSE; // TRUE if file doesn't exist yet + int msg_save = msg_scroll; + int overwriting; // TRUE if writing over original + int no_eol = FALSE; // no end-of-line written + int device = FALSE; // writing to a device + stat_T st_old; + int prev_got_int = got_int; + int checking_conversion; + int file_readonly = FALSE; // overwritten file is read-only + static char *err_readonly = "is read-only (cannot override: \"W\" in 'cpoptions')"; +#if defined(UNIX) // XXX fix me sometime? + int made_writable = FALSE; // 'w' bit has been set +#endif + // writing everything + int whole = (start == 1 && end == buf->b_ml.ml_line_count); + linenr_T old_line_count = buf->b_ml.ml_line_count; + int attr; + int fileformat; + int write_bin; + struct bw_info write_info; // info for buf_write_bytes() + int converted = FALSE; + int notconverted = FALSE; + char_u *fenc; // effective 'fileencoding' + char_u *fenc_tofree = NULL; // allocated "fenc" + int wb_flags = 0; +#ifdef HAVE_ACL + vim_acl_T acl = NULL; // ACL copied from original file to + // backup or new file +#endif +#ifdef FEAT_PERSISTENT_UNDO + int write_undo_file = FALSE; + context_sha256_T sha_ctx; +#endif + unsigned int bkc = get_bkc_value(buf); + + if (fname == NULL || *fname == NUL) // safety check + return FAIL; + if (buf->b_ml.ml_mfp == NULL) + { + // This can happen during startup when there is a stray "w" in the + // vimrc file. + emsg(_(e_emptybuf)); + return FAIL; + } + + // Disallow writing from .exrc and .vimrc in current directory for + // security reasons. + if (check_secure()) + return FAIL; + + // Avoid a crash for a long name. + if (STRLEN(fname) >= MAXPATHL) + { + emsg(_(e_longname)); + return FAIL; + } + + // must init bw_conv_buf and bw_iconv_fd before jumping to "fail" + write_info.bw_conv_buf = NULL; + write_info.bw_conv_error = FALSE; + write_info.bw_conv_error_lnum = 0; + write_info.bw_restlen = 0; +#ifdef USE_ICONV + write_info.bw_iconv_fd = (iconv_t)-1; +#endif +#ifdef FEAT_CRYPT + write_info.bw_buffer = buf; +#endif + + // After writing a file changedtick changes but we don't want to display + // the line. + ex_no_reprint = TRUE; + + // If there is no file name yet, use the one for the written file. + // BF_NOTEDITED is set to reflect this (in case the write fails). + // Don't do this when the write is for a filter command. + // Don't do this when appending. + // Only do this when 'cpoptions' contains the 'F' flag. + if (buf->b_ffname == NULL + && reset_changed + && whole + && buf == curbuf +#ifdef FEAT_QUICKFIX + && !bt_nofilename(buf) +#endif + && !filtering + && (!append || vim_strchr(p_cpo, CPO_FNAMEAPP) != NULL) + && vim_strchr(p_cpo, CPO_FNAMEW) != NULL) + { + if (set_rw_fname(fname, sfname) == FAIL) + return FAIL; + buf = curbuf; // just in case autocmds made "buf" invalid + } + + if (sfname == NULL) + sfname = fname; + // For Unix: Use the short file name whenever possible. + // Avoids problems with networks and when directory names are changed. + // Don't do this for MS-DOS, a "cd" in a sub-shell may have moved us to + // another directory, which we don't detect + ffname = fname; // remember full fname +#ifdef UNIX + fname = sfname; +#endif + + if (buf->b_ffname != NULL && fnamecmp(ffname, buf->b_ffname) == 0) + overwriting = TRUE; + else + overwriting = FALSE; + + if (exiting) + settmode(TMODE_COOK); // when exiting allow typeahead now + + ++no_wait_return; // don't wait for return yet + + // Set '[ and '] marks to the lines to be written. + buf->b_op_start.lnum = start; + buf->b_op_start.col = 0; + buf->b_op_end.lnum = end; + buf->b_op_end.col = 0; + + { + aco_save_T aco; + int buf_ffname = FALSE; + int buf_sfname = FALSE; + int buf_fname_f = FALSE; + int buf_fname_s = FALSE; + int did_cmd = FALSE; + int nofile_err = FALSE; + int empty_memline = (buf->b_ml.ml_mfp == NULL); + bufref_T bufref; + + // Apply PRE autocommands. + // Set curbuf to the buffer to be written. + // Careful: The autocommands may call buf_write() recursively! + if (ffname == buf->b_ffname) + buf_ffname = TRUE; + if (sfname == buf->b_sfname) + buf_sfname = TRUE; + if (fname == buf->b_ffname) + buf_fname_f = TRUE; + if (fname == buf->b_sfname) + buf_fname_s = TRUE; + + // set curwin/curbuf to buf and save a few things + aucmd_prepbuf(&aco, buf); + set_bufref(&bufref, buf); + + if (append) + { + if (!(did_cmd = apply_autocmds_exarg(EVENT_FILEAPPENDCMD, + sfname, sfname, FALSE, curbuf, eap))) + { +#ifdef FEAT_QUICKFIX + if (overwriting && bt_nofilename(curbuf)) + nofile_err = TRUE; + else +#endif + apply_autocmds_exarg(EVENT_FILEAPPENDPRE, + sfname, sfname, FALSE, curbuf, eap); + } + } + else if (filtering) + { + apply_autocmds_exarg(EVENT_FILTERWRITEPRE, + NULL, sfname, FALSE, curbuf, eap); + } + else if (reset_changed && whole) + { + int was_changed = curbufIsChanged(); + + did_cmd = apply_autocmds_exarg(EVENT_BUFWRITECMD, + sfname, sfname, FALSE, curbuf, eap); + if (did_cmd) + { + if (was_changed && !curbufIsChanged()) + { + // Written everything correctly and BufWriteCmd has reset + // 'modified': Correct the undo information so that an + // undo now sets 'modified'. + u_unchanged(curbuf); + u_update_save_nr(curbuf); + } + } + else + { +#ifdef FEAT_QUICKFIX + if (overwriting && bt_nofilename(curbuf)) + nofile_err = TRUE; + else +#endif + apply_autocmds_exarg(EVENT_BUFWRITEPRE, + sfname, sfname, FALSE, curbuf, eap); + } + } + else + { + if (!(did_cmd = apply_autocmds_exarg(EVENT_FILEWRITECMD, + sfname, sfname, FALSE, curbuf, eap))) + { +#ifdef FEAT_QUICKFIX + if (overwriting && bt_nofilename(curbuf)) + nofile_err = TRUE; + else +#endif + apply_autocmds_exarg(EVENT_FILEWRITEPRE, + sfname, sfname, FALSE, curbuf, eap); + } + } + + // restore curwin/curbuf and a few other things + aucmd_restbuf(&aco); + + // In three situations we return here and don't write the file: + // 1. the autocommands deleted or unloaded the buffer. + // 2. The autocommands abort script processing. + // 3. If one of the "Cmd" autocommands was executed. + if (!bufref_valid(&bufref)) + buf = NULL; + if (buf == NULL || (buf->b_ml.ml_mfp == NULL && !empty_memline) + || did_cmd || nofile_err +#ifdef FEAT_EVAL + || aborting() +#endif + ) + { + --no_wait_return; + msg_scroll = msg_save; + if (nofile_err) + emsg(_("E676: No matching autocommands for acwrite buffer")); + + if (nofile_err +#ifdef FEAT_EVAL + || aborting() +#endif + ) + // An aborting error, interrupt or exception in the + // autocommands. + return FAIL; + if (did_cmd) + { + if (buf == NULL) + // The buffer was deleted. We assume it was written + // (can't retry anyway). + return OK; + if (overwriting) + { + // Assume the buffer was written, update the timestamp. + ml_timestamp(buf); + if (append) + buf->b_flags &= ~BF_NEW; + else + buf->b_flags &= ~BF_WRITE_MASK; + } + if (reset_changed && buf->b_changed && !append + && (overwriting || vim_strchr(p_cpo, CPO_PLUS) != NULL)) + // Buffer still changed, the autocommands didn't work + // properly. + return FAIL; + return OK; + } +#ifdef FEAT_EVAL + if (!aborting()) +#endif + emsg(_("E203: Autocommands deleted or unloaded buffer to be written")); + return FAIL; + } + + // The autocommands may have changed the number of lines in the file. + // When writing the whole file, adjust the end. + // When writing part of the file, assume that the autocommands only + // changed the number of lines that are to be written (tricky!). + if (buf->b_ml.ml_line_count != old_line_count) + { + if (whole) // write all + end = buf->b_ml.ml_line_count; + else if (buf->b_ml.ml_line_count > old_line_count) // more lines + end += buf->b_ml.ml_line_count - old_line_count; + else // less lines + { + end -= old_line_count - buf->b_ml.ml_line_count; + if (end < start) + { + --no_wait_return; + msg_scroll = msg_save; + emsg(_("E204: Autocommand changed number of lines in unexpected way")); + return FAIL; + } + } + } + + // The autocommands may have changed the name of the buffer, which may + // be kept in fname, ffname and sfname. + if (buf_ffname) + ffname = buf->b_ffname; + if (buf_sfname) + sfname = buf->b_sfname; + if (buf_fname_f) + fname = buf->b_ffname; + if (buf_fname_s) + fname = buf->b_sfname; + } + +#ifdef FEAT_NETBEANS_INTG + if (netbeans_active() && isNetbeansBuffer(buf)) + { + if (whole) + { + // b_changed can be 0 after an undo, but we still need to write + // the buffer to NetBeans. + if (buf->b_changed || isNetbeansModified(buf)) + { + --no_wait_return; // may wait for return now + msg_scroll = msg_save; + netbeans_save_buffer(buf); // no error checking... + return retval; + } + else + { + errnum = (char_u *)"E656: "; + errmsg = (char_u *)_("NetBeans disallows writes of unmodified buffers"); + buffer = NULL; + goto fail; + } + } + else + { + errnum = (char_u *)"E657: "; + errmsg = (char_u *)_("Partial writes disallowed for NetBeans buffers"); + buffer = NULL; + goto fail; + } + } +#endif + + if (shortmess(SHM_OVER) && !exiting) + msg_scroll = FALSE; // overwrite previous file message + else + msg_scroll = TRUE; // don't overwrite previous file message + if (!filtering) + filemess(buf, +#ifndef UNIX + sfname, +#else + fname, +#endif + (char_u *)"", 0); // show that we are busy + msg_scroll = FALSE; // always overwrite the file message now + + buffer = alloc(WRITEBUFSIZE); + if (buffer == NULL) // can't allocate big buffer, use small + // one (to be able to write when out of + // memory) + { + buffer = smallbuf; + bufsize = SMALLBUFSIZE; + } + else + bufsize = WRITEBUFSIZE; + + // Get information about original file (if there is one). +#if defined(UNIX) + st_old.st_dev = 0; + st_old.st_ino = 0; + perm = -1; + if (mch_stat((char *)fname, &st_old) < 0) + newfile = TRUE; + else + { + perm = st_old.st_mode; + if (!S_ISREG(st_old.st_mode)) // not a file + { + if (S_ISDIR(st_old.st_mode)) + { + errnum = (char_u *)"E502: "; + errmsg = (char_u *)_("is a directory"); + goto fail; + } + if (mch_nodetype(fname) != NODE_WRITABLE) + { + errnum = (char_u *)"E503: "; + errmsg = (char_u *)_("is not a file or writable device"); + goto fail; + } + // It's a device of some kind (or a fifo) which we can write to + // but for which we can't make a backup. + device = TRUE; + newfile = TRUE; + perm = -1; + } + } +#else // !UNIX + // Check for a writable device name. + c = mch_nodetype(fname); + if (c == NODE_OTHER) + { + errnum = (char_u *)"E503: "; + errmsg = (char_u *)_("is not a file or writable device"); + goto fail; + } + if (c == NODE_WRITABLE) + { +# if defined(MSWIN) + // MS-Windows allows opening a device, but we will probably get stuck + // trying to write to it. + if (!p_odev) + { + errnum = (char_u *)"E796: "; + errmsg = (char_u *)_("writing to device disabled with 'opendevice' option"); + goto fail; + } +# endif + device = TRUE; + newfile = TRUE; + perm = -1; + } + else + { + perm = mch_getperm(fname); + if (perm < 0) + newfile = TRUE; + else if (mch_isdir(fname)) + { + errnum = (char_u *)"E502: "; + errmsg = (char_u *)_("is a directory"); + goto fail; + } + if (overwriting) + (void)mch_stat((char *)fname, &st_old); + } +#endif // !UNIX + + if (!device && !newfile) + { + // Check if the file is really writable (when renaming the file to + // make a backup we won't discover it later). + file_readonly = check_file_readonly(fname, (int)perm); + + if (!forceit && file_readonly) + { + if (vim_strchr(p_cpo, CPO_FWRITE) != NULL) + { + errnum = (char_u *)"E504: "; + errmsg = (char_u *)_(err_readonly); + } + else + { + errnum = (char_u *)"E505: "; + errmsg = (char_u *)_("is read-only (add ! to override)"); + } + goto fail; + } + + // Check if the timestamp hasn't changed since reading the file. + if (overwriting) + { + retval = check_mtime(buf, &st_old); + if (retval == FAIL) + goto fail; + } + } + +#ifdef HAVE_ACL + // For systems that support ACL: get the ACL from the original file. + if (!newfile) + acl = mch_get_acl(fname); +#endif + + // If 'backupskip' is not empty, don't make a backup for some files. + dobackup = (p_wb || p_bk || *p_pm != NUL); +#ifdef FEAT_WILDIGN + if (dobackup && *p_bsk != NUL && match_file_list(p_bsk, sfname, ffname)) + dobackup = FALSE; +#endif + + // Save the value of got_int and reset it. We don't want a previous + // interruption cancel writing, only hitting CTRL-C while writing should + // abort it. + prev_got_int = got_int; + got_int = FALSE; + + // Mark the buffer as 'being saved' to prevent changed buffer warnings + buf->b_saving = TRUE; + + // If we are not appending or filtering, the file exists, and the + // 'writebackup', 'backup' or 'patchmode' option is set, need a backup. + // When 'patchmode' is set also make a backup when appending. + // + // Do not make any backup, if 'writebackup' and 'backup' are both switched + // off. This helps when editing large files on almost-full disks. + if (!(append && *p_pm == NUL) && !filtering && perm >= 0 && dobackup) + { +#if defined(UNIX) || defined(MSWIN) + stat_T st; +#endif + + if ((bkc & BKC_YES) || append) // "yes" + backup_copy = TRUE; +#if defined(UNIX) || defined(MSWIN) + else if ((bkc & BKC_AUTO)) // "auto" + { + int i; + +# ifdef UNIX + // Don't rename the file when: + // - it's a hard link + // - it's a symbolic link + // - we don't have write permission in the directory + // - we can't set the owner/group of the new file + if (st_old.st_nlink > 1 + || mch_lstat((char *)fname, &st) < 0 + || st.st_dev != st_old.st_dev + || st.st_ino != st_old.st_ino +# ifndef HAVE_FCHOWN + || st.st_uid != st_old.st_uid + || st.st_gid != st_old.st_gid +# endif + ) + backup_copy = TRUE; + else +# else +# ifdef MSWIN + // On NTFS file systems hard links are possible. + if (mch_is_linked(fname)) + backup_copy = TRUE; + else +# endif +# endif + { + // Check if we can create a file and set the owner/group to + // the ones from the original file. + // First find a file name that doesn't exist yet (use some + // arbitrary numbers). + STRCPY(IObuff, fname); + for (i = 4913; ; i += 123) + { + sprintf((char *)gettail(IObuff), "%d", i); + if (mch_lstat((char *)IObuff, &st) < 0) + break; + } + fd = mch_open((char *)IObuff, + O_CREAT|O_WRONLY|O_EXCL|O_NOFOLLOW, perm); + if (fd < 0) // can't write in directory + backup_copy = TRUE; + else + { +# ifdef UNIX +# ifdef HAVE_FCHOWN + vim_ignored = fchown(fd, st_old.st_uid, st_old.st_gid); +# endif + if (mch_stat((char *)IObuff, &st) < 0 + || st.st_uid != st_old.st_uid + || st.st_gid != st_old.st_gid + || (long)st.st_mode != perm) + backup_copy = TRUE; +# endif + // Close the file before removing it, on MS-Windows we + // can't delete an open file. + close(fd); + mch_remove(IObuff); +# ifdef MSWIN + // MS-Windows may trigger a virus scanner to open the + // file, we can't delete it then. Keep trying for half a + // second. + { + int try; + + for (try = 0; try < 10; ++try) + { + if (mch_lstat((char *)IObuff, &st) < 0) + break; + ui_delay(50L, TRUE); // wait 50 msec + mch_remove(IObuff); + } + } +# endif + } + } + } + + // Break symlinks and/or hardlinks if we've been asked to. + if ((bkc & BKC_BREAKSYMLINK) || (bkc & BKC_BREAKHARDLINK)) + { +# ifdef UNIX + int lstat_res; + + lstat_res = mch_lstat((char *)fname, &st); + + // Symlinks. + if ((bkc & BKC_BREAKSYMLINK) + && lstat_res == 0 + && st.st_ino != st_old.st_ino) + backup_copy = FALSE; + + // Hardlinks. + if ((bkc & BKC_BREAKHARDLINK) + && st_old.st_nlink > 1 + && (lstat_res != 0 || st.st_ino == st_old.st_ino)) + backup_copy = FALSE; +# else +# if defined(MSWIN) + // Symlinks. + if ((bkc & BKC_BREAKSYMLINK) && mch_is_symbolic_link(fname)) + backup_copy = FALSE; + + // Hardlinks. + if ((bkc & BKC_BREAKHARDLINK) && mch_is_hard_link(fname)) + backup_copy = FALSE; +# endif +# endif + } + +#endif + + // make sure we have a valid backup extension to use + if (*p_bex == NUL) + backup_ext = (char_u *)".bak"; + else + backup_ext = p_bex; + + if (backup_copy + && (fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0)) >= 0) + { + int bfd; + char_u *copybuf, *wp; + int some_error = FALSE; + stat_T st_new; + char_u *dirp; + char_u *rootname; +#if defined(UNIX) || defined(MSWIN) + char_u *p; +#endif +#if defined(UNIX) + int did_set_shortname; + mode_t umask_save; +#endif + + copybuf = alloc(WRITEBUFSIZE + 1); + if (copybuf == NULL) + { + some_error = TRUE; // out of memory + goto nobackup; + } + + // Try to make the backup in each directory in the 'bdir' option. + // + // Unix semantics has it, that we may have a writable file, + // that cannot be recreated with a simple open(..., O_CREAT, ) e.g: + // - the directory is not writable, + // - the file may be a symbolic link, + // - the file may belong to another user/group, etc. + // + // For these reasons, the existing writable file must be truncated + // and reused. Creation of a backup COPY will be attempted. + dirp = p_bdir; + while (*dirp) + { +#ifdef UNIX + st_new.st_ino = 0; + st_new.st_dev = 0; + st_new.st_gid = 0; +#endif + + // Isolate one directory name, using an entry in 'bdir'. + (void)copy_option_part(&dirp, copybuf, WRITEBUFSIZE, ","); + +#if defined(UNIX) || defined(MSWIN) + p = copybuf + STRLEN(copybuf); + if (after_pathsep(copybuf, p) && p[-1] == p[-2]) + // Ends with '//', use full path + if ((p = make_percent_swname(copybuf, fname)) != NULL) + { + backup = modname(p, backup_ext, FALSE); + vim_free(p); + } +#endif + rootname = get_file_in_dir(fname, copybuf); + if (rootname == NULL) + { + some_error = TRUE; // out of memory + goto nobackup; + } + +#if defined(UNIX) + did_set_shortname = FALSE; +#endif + + // May try twice if 'shortname' not set. + for (;;) + { + // Make the backup file name. + if (backup == NULL) + backup = buf_modname((buf->b_p_sn || buf->b_shortname), + rootname, backup_ext, FALSE); + if (backup == NULL) + { + vim_free(rootname); + some_error = TRUE; // out of memory + goto nobackup; + } + + // Check if backup file already exists. + if (mch_stat((char *)backup, &st_new) >= 0) + { +#ifdef UNIX + // Check if backup file is same as original file. + // May happen when modname() gave the same file back. + // E.g. silly link, or file name-length reached. + // If we don't check here, we either ruin the file + // when copying or erase it after writing. jw. + if (st_new.st_dev == st_old.st_dev + && st_new.st_ino == st_old.st_ino) + { + VIM_CLEAR(backup); // no backup file to delete + // may try again with 'shortname' set + if (!(buf->b_shortname || buf->b_p_sn)) + { + buf->b_shortname = TRUE; + did_set_shortname = TRUE; + continue; + } + // setting shortname didn't help + if (did_set_shortname) + buf->b_shortname = FALSE; + break; + } +#endif + + // If we are not going to keep the backup file, don't + // delete an existing one, try to use another name. + // Change one character, just before the extension. + if (!p_bk) + { + wp = backup + STRLEN(backup) - 1 + - STRLEN(backup_ext); + if (wp < backup) // empty file name ??? + wp = backup; + *wp = 'z'; + while (*wp > 'a' + && mch_stat((char *)backup, &st_new) >= 0) + --*wp; + // They all exist??? Must be something wrong. + if (*wp == 'a') + VIM_CLEAR(backup); + } + } + break; + } + vim_free(rootname); + + // Try to create the backup file + if (backup != NULL) + { + // remove old backup, if present + mch_remove(backup); + // Open with O_EXCL to avoid the file being created while + // we were sleeping (symlink hacker attack?). Reset umask + // if possible to avoid mch_setperm() below. +#ifdef UNIX + umask_save = umask(0); +#endif + bfd = mch_open((char *)backup, + O_WRONLY|O_CREAT|O_EXTRA|O_EXCL|O_NOFOLLOW, + perm & 0777); +#ifdef UNIX + (void)umask(umask_save); +#endif + if (bfd < 0) + VIM_CLEAR(backup); + else + { + // Set file protection same as original file, but + // strip s-bit. Only needed if umask() wasn't used + // above. +#ifndef UNIX + (void)mch_setperm(backup, perm & 0777); +#else + // Try to set the group of the backup same as the + // original file. If this fails, set the protection + // bits for the group same as the protection bits for + // others. + if (st_new.st_gid != st_old.st_gid +# ifdef HAVE_FCHOWN // sequent-ptx lacks fchown() + && fchown(bfd, (uid_t)-1, st_old.st_gid) != 0 +# endif + ) + mch_setperm(backup, + (perm & 0707) | ((perm & 07) << 3)); +# if defined(HAVE_SELINUX) || defined(HAVE_SMACK) + mch_copy_sec(fname, backup); +# endif +#endif + + // copy the file. + write_info.bw_fd = bfd; + write_info.bw_buf = copybuf; + write_info.bw_flags = FIO_NOCONVERT; + while ((write_info.bw_len = read_eintr(fd, copybuf, + WRITEBUFSIZE)) > 0) + { + if (buf_write_bytes(&write_info) == FAIL) + { + errmsg = (char_u *)_("E506: Can't write to backup file (add ! to override)"); + break; + } + ui_breakcheck(); + if (got_int) + { + errmsg = (char_u *)_(e_interr); + break; + } + } + + if (close(bfd) < 0 && errmsg == NULL) + errmsg = (char_u *)_("E507: Close error for backup file (add ! to override)"); + if (write_info.bw_len < 0) + errmsg = (char_u *)_("E508: Can't read file for backup (add ! to override)"); +#ifdef UNIX + set_file_time(backup, st_old.st_atime, st_old.st_mtime); +#endif +#ifdef HAVE_ACL + mch_set_acl(backup, acl); +#endif +#if defined(HAVE_SELINUX) || defined(HAVE_SMACK) + mch_copy_sec(fname, backup); +#endif + break; + } + } + } + nobackup: + close(fd); // ignore errors for closing read file + vim_free(copybuf); + + if (backup == NULL && errmsg == NULL) + errmsg = (char_u *)_("E509: Cannot create backup file (add ! to override)"); + // ignore errors when forceit is TRUE + if ((some_error || errmsg != NULL) && !forceit) + { + retval = FAIL; + goto fail; + } + errmsg = NULL; + } + else + { + char_u *dirp; + char_u *p; + char_u *rootname; + + // Make a backup by renaming the original file. + + // If 'cpoptions' includes the "W" flag, we don't want to + // overwrite a read-only file. But rename may be possible + // anyway, thus we need an extra check here. + if (file_readonly && vim_strchr(p_cpo, CPO_FWRITE) != NULL) + { + errnum = (char_u *)"E504: "; + errmsg = (char_u *)_(err_readonly); + goto fail; + } + + // Form the backup file name - change path/fo.o.h to + // path/fo.o.h.bak Try all directories in 'backupdir', first one + // that works is used. + dirp = p_bdir; + while (*dirp) + { + // Isolate one directory name and make the backup file name. + (void)copy_option_part(&dirp, IObuff, IOSIZE, ","); + +#if defined(UNIX) || defined(MSWIN) + p = IObuff + STRLEN(IObuff); + if (after_pathsep(IObuff, p) && p[-1] == p[-2]) + // path ends with '//', use full path + if ((p = make_percent_swname(IObuff, fname)) != NULL) + { + backup = modname(p, backup_ext, FALSE); + vim_free(p); + } +#endif + if (backup == NULL) + { + rootname = get_file_in_dir(fname, IObuff); + if (rootname == NULL) + backup = NULL; + else + { + backup = buf_modname( + (buf->b_p_sn || buf->b_shortname), + rootname, backup_ext, FALSE); + vim_free(rootname); + } + } + + if (backup != NULL) + { + // If we are not going to keep the backup file, don't + // delete an existing one, try to use another name. + // Change one character, just before the extension. + if (!p_bk && mch_getperm(backup) >= 0) + { + p = backup + STRLEN(backup) - 1 - STRLEN(backup_ext); + if (p < backup) // empty file name ??? + p = backup; + *p = 'z'; + while (*p > 'a' && mch_getperm(backup) >= 0) + --*p; + // They all exist??? Must be something wrong! + if (*p == 'a') + VIM_CLEAR(backup); + } + } + if (backup != NULL) + { + // Delete any existing backup and move the current version + // to the backup. For safety, we don't remove the backup + // until the write has finished successfully. And if the + // 'backup' option is set, leave it around. + + // If the renaming of the original file to the backup file + // works, quit here. + if (vim_rename(fname, backup) == 0) + break; + + VIM_CLEAR(backup); // don't do the rename below + } + } + if (backup == NULL && !forceit) + { + errmsg = (char_u *)_("E510: Can't make backup file (add ! to override)"); + goto fail; + } + } + } + +#if defined(UNIX) + // When using ":w!" and the file was read-only: make it writable + if (forceit && perm >= 0 && !(perm & 0200) && st_old.st_uid == getuid() + && vim_strchr(p_cpo, CPO_FWRITE) == NULL) + { + perm |= 0200; + (void)mch_setperm(fname, perm); + made_writable = TRUE; + } +#endif + + // When using ":w!" and writing to the current file, 'readonly' makes no + // sense, reset it, unless 'Z' appears in 'cpoptions'. + if (forceit && overwriting && vim_strchr(p_cpo, CPO_KEEPRO) == NULL) + { + buf->b_p_ro = FALSE; +#ifdef FEAT_TITLE + need_maketitle = TRUE; // set window title later +#endif + status_redraw_all(); // redraw status lines later + } + + if (end > buf->b_ml.ml_line_count) + end = buf->b_ml.ml_line_count; + if (buf->b_ml.ml_flags & ML_EMPTY) + start = end + 1; + + // If the original file is being overwritten, there is a small chance that + // we crash in the middle of writing. Therefore the file is preserved now. + // This makes all block numbers positive so that recovery does not need + // the original file. + // Don't do this if there is a backup file and we are exiting. + if (reset_changed && !newfile && overwriting + && !(exiting && backup != NULL)) + { + ml_preserve(buf, FALSE); + if (got_int) + { + errmsg = (char_u *)_(e_interr); + goto restore_backup; + } + } + +#ifdef VMS + vms_remove_version(fname); // remove version +#endif + // Default: write the file directly. May write to a temp file for + // multi-byte conversion. + wfname = fname; + + // Check for forced 'fileencoding' from "++opt=val" argument. + if (eap != NULL && eap->force_enc != 0) + { + fenc = eap->cmd + eap->force_enc; + fenc = enc_canonize(fenc); + fenc_tofree = fenc; + } + else + fenc = buf->b_p_fenc; + + // Check if the file needs to be converted. + converted = need_conversion(fenc); + + // Check if UTF-8 to UCS-2/4 or Latin1 conversion needs to be done. Or + // Latin1 to Unicode conversion. This is handled in buf_write_bytes(). + // Prepare the flags for it and allocate bw_conv_buf when needed. + if (converted && (enc_utf8 || STRCMP(p_enc, "latin1") == 0)) + { + wb_flags = get_fio_flags(fenc); + if (wb_flags & (FIO_UCS2 | FIO_UCS4 | FIO_UTF16 | FIO_UTF8)) + { + // Need to allocate a buffer to translate into. + if (wb_flags & (FIO_UCS2 | FIO_UTF16 | FIO_UTF8)) + write_info.bw_conv_buflen = bufsize * 2; + else // FIO_UCS4 + write_info.bw_conv_buflen = bufsize * 4; + write_info.bw_conv_buf = alloc(write_info.bw_conv_buflen); + if (write_info.bw_conv_buf == NULL) + end = 0; + } + } + +#ifdef MSWIN + if (converted && wb_flags == 0 && (wb_flags = get_win_fio_flags(fenc)) != 0) + { + // Convert UTF-8 -> UCS-2 and UCS-2 -> DBCS. Worst-case * 4: + write_info.bw_conv_buflen = bufsize * 4; + write_info.bw_conv_buf = alloc(write_info.bw_conv_buflen); + if (write_info.bw_conv_buf == NULL) + end = 0; + } +#endif + +#ifdef MACOS_CONVERT + if (converted && wb_flags == 0 && (wb_flags = get_mac_fio_flags(fenc)) != 0) + { + write_info.bw_conv_buflen = bufsize * 3; + write_info.bw_conv_buf = alloc(write_info.bw_conv_buflen); + if (write_info.bw_conv_buf == NULL) + end = 0; + } +#endif + +#if defined(FEAT_EVAL) || defined(USE_ICONV) + if (converted && wb_flags == 0) + { +# ifdef USE_ICONV + // Use iconv() conversion when conversion is needed and it's not done + // internally. + write_info.bw_iconv_fd = (iconv_t)my_iconv_open(fenc, + enc_utf8 ? (char_u *)"utf-8" : p_enc); + if (write_info.bw_iconv_fd != (iconv_t)-1) + { + // We're going to use iconv(), allocate a buffer to convert in. + write_info.bw_conv_buflen = bufsize * ICONV_MULT; + write_info.bw_conv_buf = alloc(write_info.bw_conv_buflen); + if (write_info.bw_conv_buf == NULL) + end = 0; + write_info.bw_first = TRUE; + } +# ifdef FEAT_EVAL + else +# endif +# endif + +# ifdef FEAT_EVAL + // When the file needs to be converted with 'charconvert' after + // writing, write to a temp file instead and let the conversion + // overwrite the original file. + if (*p_ccv != NUL) + { + wfname = vim_tempname('w', FALSE); + if (wfname == NULL) // Can't write without a tempfile! + { + errmsg = (char_u *)_("E214: Can't find temp file for writing"); + goto restore_backup; + } + } +# endif + } +#endif + if (converted && wb_flags == 0 +#ifdef USE_ICONV + && write_info.bw_iconv_fd == (iconv_t)-1 +# endif +# ifdef FEAT_EVAL + && wfname == fname +# endif + ) + { + if (!forceit) + { + errmsg = (char_u *)_("E213: Cannot convert (add ! to write without conversion)"); + goto restore_backup; + } + notconverted = TRUE; + } + + // If conversion is taking place, we may first pretend to write and check + // for conversion errors. Then loop again to write for real. + // When not doing conversion this writes for real right away. + for (checking_conversion = TRUE; ; checking_conversion = FALSE) + { + // There is no need to check conversion when: + // - there is no conversion + // - we make a backup file, that can be restored in case of conversion + // failure. + if (!converted || dobackup) + checking_conversion = FALSE; + + if (checking_conversion) + { + // Make sure we don't write anything. + fd = -1; + write_info.bw_fd = fd; + } + else + { +#ifdef HAVE_FTRUNCATE +# define TRUNC_ON_OPEN 0 +#else +# define TRUNC_ON_OPEN O_TRUNC +#endif + // Open the file "wfname" for writing. + // We may try to open the file twice: If we can't write to the file + // and forceit is TRUE we delete the existing file and try to + // create a new one. If this still fails we may have lost the + // original file! (this may happen when the user reached his + // quotum for number of files). + // Appending will fail if the file does not exist and forceit is + // FALSE. + while ((fd = mch_open((char *)wfname, O_WRONLY | O_EXTRA | (append + ? (forceit ? (O_APPEND | O_CREAT) : O_APPEND) + : (O_CREAT | TRUNC_ON_OPEN)) + , perm < 0 ? 0666 : (perm & 0777))) < 0) + { + // A forced write will try to create a new file if the old one + // is still readonly. This may also happen when the directory + // is read-only. In that case the mch_remove() will fail. + if (errmsg == NULL) + { +#ifdef UNIX + stat_T st; + + // Don't delete the file when it's a hard or symbolic link. + if ((!newfile && st_old.st_nlink > 1) + || (mch_lstat((char *)fname, &st) == 0 + && (st.st_dev != st_old.st_dev + || st.st_ino != st_old.st_ino))) + errmsg = (char_u *)_("E166: Can't open linked file for writing"); + else +#endif + { + errmsg = (char_u *)_("E212: Can't open file for writing"); + if (forceit && vim_strchr(p_cpo, CPO_FWRITE) == NULL + && perm >= 0) + { +#ifdef UNIX + // we write to the file, thus it should be marked + // writable after all + if (!(perm & 0200)) + made_writable = TRUE; + perm |= 0200; + if (st_old.st_uid != getuid() + || st_old.st_gid != getgid()) + perm &= 0777; +#endif + if (!append) // don't remove when appending + mch_remove(wfname); + continue; + } + } + } + +restore_backup: + { + stat_T st; + + // If we failed to open the file, we don't need a backup. + // Throw it away. If we moved or removed the original file + // try to put the backup in its place. + if (backup != NULL && wfname == fname) + { + if (backup_copy) + { + // There is a small chance that we removed the + // original, try to move the copy in its place. + // This may not work if the vim_rename() fails. + // In that case we leave the copy around. + + // If file does not exist, put the copy in its + // place + if (mch_stat((char *)fname, &st) < 0) + vim_rename(backup, fname); + // if original file does exist throw away the copy + if (mch_stat((char *)fname, &st) >= 0) + mch_remove(backup); + } + else + { + // try to put the original file back + vim_rename(backup, fname); + } + } + + // if original file no longer exists give an extra warning + if (!newfile && mch_stat((char *)fname, &st) < 0) + end = 0; + } + + if (wfname != fname) + vim_free(wfname); + goto fail; + } + write_info.bw_fd = fd; + +#if defined(UNIX) + { + stat_T st; + + // Double check we are writing the intended file before making + // any changes. + if (overwriting + && (!dobackup || backup_copy) + && fname == wfname + && perm >= 0 + && mch_fstat(fd, &st) == 0 + && st.st_ino != st_old.st_ino) + { + close(fd); + errmsg = (char_u *)_("E949: File changed while writing"); + goto fail; + } + } +#endif +#ifdef HAVE_FTRUNCATE + if (!append) + vim_ignored = ftruncate(fd, (off_t)0); +#endif + +#if defined(MSWIN) + if (backup != NULL && overwriting && !append) + { + if (backup_copy) + (void)mch_copy_file_attribute(wfname, backup); + else + (void)mch_copy_file_attribute(backup, wfname); + } + + if (!overwriting && !append) + { + if (buf->b_ffname != NULL) + (void)mch_copy_file_attribute(buf->b_ffname, wfname); + // Should copy resource fork + } +#endif + +#ifdef FEAT_CRYPT + if (*buf->b_p_key != NUL && !filtering) + { + char_u *header; + int header_len; + + buf->b_cryptstate = crypt_create_for_writing( + crypt_get_method_nr(buf), + buf->b_p_key, &header, &header_len); + if (buf->b_cryptstate == NULL || header == NULL) + end = 0; + else + { + // Write magic number, so that Vim knows how this file is + // encrypted when reading it back. + write_info.bw_buf = header; + write_info.bw_len = header_len; + write_info.bw_flags = FIO_NOCONVERT; + if (buf_write_bytes(&write_info) == FAIL) + end = 0; + wb_flags |= FIO_ENCRYPTED; + vim_free(header); + } + } +#endif + } + errmsg = NULL; + + write_info.bw_buf = buffer; + nchars = 0; + + // use "++bin", "++nobin" or 'binary' + if (eap != NULL && eap->force_bin != 0) + write_bin = (eap->force_bin == FORCE_BIN); + else + write_bin = buf->b_p_bin; + + // The BOM is written just after the encryption magic number. + // Skip it when appending and the file already existed, the BOM only + // makes sense at the start of the file. + if (buf->b_p_bomb && !write_bin && (!append || perm < 0)) + { + write_info.bw_len = make_bom(buffer, fenc); + if (write_info.bw_len > 0) + { + // don't convert, do encryption + write_info.bw_flags = FIO_NOCONVERT | wb_flags; + if (buf_write_bytes(&write_info) == FAIL) + end = 0; + else + nchars += write_info.bw_len; + } + } + write_info.bw_start_lnum = start; + +#ifdef FEAT_PERSISTENT_UNDO + write_undo_file = (buf->b_p_udf + && overwriting + && !append + && !filtering + && reset_changed + && !checking_conversion); + if (write_undo_file) + // Prepare for computing the hash value of the text. + sha256_start(&sha_ctx); +#endif + + write_info.bw_len = bufsize; + write_info.bw_flags = wb_flags; + fileformat = get_fileformat_force(buf, eap); + s = buffer; + len = 0; + for (lnum = start; lnum <= end; ++lnum) + { + // The next while loop is done once for each character written. + // Keep it fast! + ptr = ml_get_buf(buf, lnum, FALSE) - 1; +#ifdef FEAT_PERSISTENT_UNDO + if (write_undo_file) + sha256_update(&sha_ctx, ptr + 1, + (UINT32_T)(STRLEN(ptr + 1) + 1)); +#endif + while ((c = *++ptr) != NUL) + { + if (c == NL) + *s = NUL; // replace newlines with NULs + else if (c == CAR && fileformat == EOL_MAC) + *s = NL; // Mac: replace CRs with NLs + else + *s = c; + ++s; + if (++len != bufsize) + continue; + if (buf_write_bytes(&write_info) == FAIL) + { + end = 0; // write error: break loop + break; + } + nchars += bufsize; + s = buffer; + len = 0; + write_info.bw_start_lnum = lnum; + } + // write failed or last line has no EOL: stop here + if (end == 0 + || (lnum == end + && (write_bin || !buf->b_p_fixeol) + && (lnum == buf->b_no_eol_lnum + || (lnum == buf->b_ml.ml_line_count + && !buf->b_p_eol)))) + { + ++lnum; // written the line, count it + no_eol = TRUE; + break; + } + if (fileformat == EOL_UNIX) + *s++ = NL; + else + { + *s++ = CAR; // EOL_MAC or EOL_DOS: write CR + if (fileformat == EOL_DOS) // write CR-NL + { + if (++len == bufsize) + { + if (buf_write_bytes(&write_info) == FAIL) + { + end = 0; // write error: break loop + break; + } + nchars += bufsize; + s = buffer; + len = 0; + } + *s++ = NL; + } + } + if (++len == bufsize && end) + { + if (buf_write_bytes(&write_info) == FAIL) + { + end = 0; // write error: break loop + break; + } + nchars += bufsize; + s = buffer; + len = 0; + + ui_breakcheck(); + if (got_int) + { + end = 0; // Interrupted, break loop + break; + } + } +#ifdef VMS + // On VMS there is a problem: newlines get added when writing + // blocks at a time. Fix it by writing a line at a time. + // This is much slower! + // Explanation: VAX/DECC RTL insists that records in some RMS + // structures end with a newline (carriage return) character, and + // if they don't it adds one. + // With other RMS structures it works perfect without this fix. + if (buf->b_fab_rfm == FAB$C_VFC + || ((buf->b_fab_rat & (FAB$M_FTN | FAB$M_CR)) != 0)) + { + int b2write; + + buf->b_fab_mrs = (buf->b_fab_mrs == 0 + ? MIN(4096, bufsize) + : MIN(buf->b_fab_mrs, bufsize)); + + b2write = len; + while (b2write > 0) + { + write_info.bw_len = MIN(b2write, buf->b_fab_mrs); + if (buf_write_bytes(&write_info) == FAIL) + { + end = 0; + break; + } + b2write -= MIN(b2write, buf->b_fab_mrs); + } + write_info.bw_len = bufsize; + nchars += len; + s = buffer; + len = 0; + } +#endif + } + if (len > 0 && end > 0) + { + write_info.bw_len = len; + if (buf_write_bytes(&write_info) == FAIL) + end = 0; // write error + nchars += len; + } + + // Stop when writing done or an error was encountered. + if (!checking_conversion || end == 0) + break; + + // If no error happened until now, writing should be ok, so loop to + // really write the buffer. + } + + // If we started writing, finish writing. Also when an error was + // encountered. + if (!checking_conversion) + { +#if defined(UNIX) && defined(HAVE_FSYNC) + // On many journalling file systems there is a bug that causes both the + // original and the backup file to be lost when halting the system + // right after writing the file. That's because only the meta-data is + // journalled. Syncing the file slows down the system, but assures it + // has been written to disk and we don't lose it. + // For a device do try the fsync() but don't complain if it does not + // work (could be a pipe). + // If the 'fsync' option is FALSE, don't fsync(). Useful for laptops. + if (p_fs && vim_fsync(fd) != 0 && !device) + { + errmsg = (char_u *)_(e_fsync); + end = 0; + } +#endif + +#if defined(HAVE_SELINUX) || defined(HAVE_SMACK) + // Probably need to set the security context. + if (!backup_copy) + mch_copy_sec(backup, wfname); +#endif + +#ifdef UNIX + // When creating a new file, set its owner/group to that of the + // original file. Get the new device and inode number. + if (backup != NULL && !backup_copy) + { +# ifdef HAVE_FCHOWN + stat_T st; + + // Don't change the owner when it's already OK, some systems remove + // permission or ACL stuff. + if (mch_stat((char *)wfname, &st) < 0 + || st.st_uid != st_old.st_uid + || st.st_gid != st_old.st_gid) + { + // changing owner might not be possible + vim_ignored = fchown(fd, st_old.st_uid, -1); + // if changing group fails clear the group permissions + if (fchown(fd, -1, st_old.st_gid) == -1 && perm > 0) + perm &= ~070; + } +# endif + buf_setino(buf); + } + else if (!buf->b_dev_valid) + // Set the inode when creating a new file. + buf_setino(buf); +#endif + +#ifdef UNIX + if (made_writable) + perm &= ~0200; // reset 'w' bit for security reasons +#endif +#ifdef HAVE_FCHMOD + // set permission of new file same as old file + if (perm >= 0) + (void)mch_fsetperm(fd, perm); +#endif + if (close(fd) != 0) + { + errmsg = (char_u *)_("E512: Close failed"); + end = 0; + } + +#ifndef HAVE_FCHMOD + // set permission of new file same as old file + if (perm >= 0) + (void)mch_setperm(wfname, perm); +#endif +#ifdef HAVE_ACL + // Probably need to set the ACL before changing the user (can't set the + // ACL on a file the user doesn't own). + // On Solaris, with ZFS and the aclmode property set to "discard" (the + // default), chmod() discards all part of a file's ACL that don't + // represent the mode of the file. It's non-trivial for us to discover + // whether we're in that situation, so we simply always re-set the ACL. +# ifndef HAVE_SOLARIS_ZFS_ACL + if (!backup_copy) +# endif + mch_set_acl(wfname, acl); +#endif +#ifdef FEAT_CRYPT + if (buf->b_cryptstate != NULL) + { + crypt_free_state(buf->b_cryptstate); + buf->b_cryptstate = NULL; + } +#endif + +#if defined(FEAT_EVAL) + if (wfname != fname) + { + // The file was written to a temp file, now it needs to be + // converted with 'charconvert' to (overwrite) the output file. + if (end != 0) + { + if (eval_charconvert(enc_utf8 ? (char_u *)"utf-8" : p_enc, + fenc, wfname, fname) == FAIL) + { + write_info.bw_conv_error = TRUE; + end = 0; + } + } + mch_remove(wfname); + vim_free(wfname); + } +#endif + } + + if (end == 0) + { + // Error encountered. + if (errmsg == NULL) + { + if (write_info.bw_conv_error) + { + if (write_info.bw_conv_error_lnum == 0) + errmsg = (char_u *)_("E513: write error, conversion failed (make 'fenc' empty to override)"); + else + { + errmsg_allocated = TRUE; + errmsg = alloc(300); + vim_snprintf((char *)errmsg, 300, _("E513: write error, conversion failed in line %ld (make 'fenc' empty to override)"), + (long)write_info.bw_conv_error_lnum); + } + } + else if (got_int) + errmsg = (char_u *)_(e_interr); + else + errmsg = (char_u *)_("E514: write error (file system full?)"); + } + + // If we have a backup file, try to put it in place of the new file, + // because the new file is probably corrupt. This avoids losing the + // original file when trying to make a backup when writing the file a + // second time. + // When "backup_copy" is set we need to copy the backup over the new + // file. Otherwise rename the backup file. + // If this is OK, don't give the extra warning message. + if (backup != NULL) + { + if (backup_copy) + { + // This may take a while, if we were interrupted let the user + // know we got the message. + if (got_int) + { + msg(_(e_interr)); + out_flush(); + } + if ((fd = mch_open((char *)backup, O_RDONLY | O_EXTRA, 0)) >= 0) + { + if ((write_info.bw_fd = mch_open((char *)fname, + O_WRONLY | O_CREAT | O_TRUNC | O_EXTRA, + perm & 0777)) >= 0) + { + // copy the file. + write_info.bw_buf = smallbuf; + write_info.bw_flags = FIO_NOCONVERT; + while ((write_info.bw_len = read_eintr(fd, smallbuf, + SMALLBUFSIZE)) > 0) + if (buf_write_bytes(&write_info) == FAIL) + break; + + if (close(write_info.bw_fd) >= 0 + && write_info.bw_len == 0) + end = 1; // success + } + close(fd); // ignore errors for closing read file + } + } + else + { + if (vim_rename(backup, fname) == 0) + end = 1; + } + } + goto fail; + } + + lnum -= start; // compute number of written lines + --no_wait_return; // may wait for return now + +#if !(defined(UNIX) || defined(VMS)) + fname = sfname; // use shortname now, for the messages +#endif + if (!filtering) + { + msg_add_fname(buf, fname); // put fname in IObuff with quotes + c = FALSE; + if (write_info.bw_conv_error) + { + STRCAT(IObuff, _(" CONVERSION ERROR")); + c = TRUE; + if (write_info.bw_conv_error_lnum != 0) + vim_snprintf_add((char *)IObuff, IOSIZE, _(" in line %ld;"), + (long)write_info.bw_conv_error_lnum); + } + else if (notconverted) + { + STRCAT(IObuff, _("[NOT converted]")); + c = TRUE; + } + else if (converted) + { + STRCAT(IObuff, _("[converted]")); + c = TRUE; + } + if (device) + { + STRCAT(IObuff, _("[Device]")); + c = TRUE; + } + else if (newfile) + { + STRCAT(IObuff, shortmess(SHM_NEW) ? _("[New]") : _("[New File]")); + c = TRUE; + } + if (no_eol) + { + msg_add_eol(); + c = TRUE; + } + // may add [unix/dos/mac] + if (msg_add_fileformat(fileformat)) + c = TRUE; +#ifdef FEAT_CRYPT + if (wb_flags & FIO_ENCRYPTED) + { + crypt_append_msg(buf); + c = TRUE; + } +#endif + msg_add_lines(c, (long)lnum, nchars); // add line/char count + if (!shortmess(SHM_WRITE)) + { + if (append) + STRCAT(IObuff, shortmess(SHM_WRI) ? _(" [a]") : _(" appended")); + else + STRCAT(IObuff, shortmess(SHM_WRI) ? _(" [w]") : _(" written")); + } + + set_keep_msg((char_u *)msg_trunc_attr((char *)IObuff, FALSE, 0), 0); + } + + // When written everything correctly: reset 'modified'. Unless not + // writing to the original file and '+' is not in 'cpoptions'. + if (reset_changed && whole && !append + && !write_info.bw_conv_error + && (overwriting || vim_strchr(p_cpo, CPO_PLUS) != NULL)) + { + unchanged(buf, TRUE, FALSE); + // b:changedtick is may be incremented in unchanged() but that + // should not trigger a TextChanged event. + if (buf->b_last_changedtick + 1 == CHANGEDTICK(buf)) + buf->b_last_changedtick = CHANGEDTICK(buf); + u_unchanged(buf); + u_update_save_nr(buf); + } + + // If written to the current file, update the timestamp of the swap file + // and reset the BF_WRITE_MASK flags. Also sets buf->b_mtime. + if (overwriting) + { + ml_timestamp(buf); + if (append) + buf->b_flags &= ~BF_NEW; + else + buf->b_flags &= ~BF_WRITE_MASK; + } + + // If we kept a backup until now, and we are in patch mode, then we make + // the backup file our 'original' file. + if (*p_pm && dobackup) + { + char *org = (char *)buf_modname((buf->b_p_sn || buf->b_shortname), + fname, p_pm, FALSE); + + if (backup != NULL) + { + stat_T st; + + // If the original file does not exist yet + // the current backup file becomes the original file + if (org == NULL) + emsg(_("E205: Patchmode: can't save original file")); + else if (mch_stat(org, &st) < 0) + { + vim_rename(backup, (char_u *)org); + VIM_CLEAR(backup); // don't delete the file +#ifdef UNIX + set_file_time((char_u *)org, st_old.st_atime, st_old.st_mtime); +#endif + } + } + // If there is no backup file, remember that a (new) file was + // created. + else + { + int empty_fd; + + if (org == NULL + || (empty_fd = mch_open(org, + O_CREAT | O_EXTRA | O_EXCL | O_NOFOLLOW, + perm < 0 ? 0666 : (perm & 0777))) < 0) + emsg(_("E206: patchmode: can't touch empty original file")); + else + close(empty_fd); + } + if (org != NULL) + { + mch_setperm((char_u *)org, mch_getperm(fname) & 0777); + vim_free(org); + } + } + + // Remove the backup unless 'backup' option is set or there was a + // conversion error. + if (!p_bk && backup != NULL && !write_info.bw_conv_error + && mch_remove(backup) != 0) + emsg(_("E207: Can't delete backup file")); + + goto nofail; + + // Finish up. We get here either after failure or success. +fail: + --no_wait_return; // may wait for return now +nofail: + + // Done saving, we accept changed buffer warnings again + buf->b_saving = FALSE; + + vim_free(backup); + if (buffer != smallbuf) + vim_free(buffer); + vim_free(fenc_tofree); + vim_free(write_info.bw_conv_buf); +#ifdef USE_ICONV + if (write_info.bw_iconv_fd != (iconv_t)-1) + { + iconv_close(write_info.bw_iconv_fd); + write_info.bw_iconv_fd = (iconv_t)-1; + } +#endif +#ifdef HAVE_ACL + mch_free_acl(acl); +#endif + + if (errmsg != NULL) + { + int numlen = errnum != NULL ? (int)STRLEN(errnum) : 0; + + attr = HL_ATTR(HLF_E); // set highlight for error messages + msg_add_fname(buf, +#ifndef UNIX + sfname +#else + fname +#endif + ); // put file name in IObuff with quotes + if (STRLEN(IObuff) + STRLEN(errmsg) + numlen >= IOSIZE) + IObuff[IOSIZE - STRLEN(errmsg) - numlen - 1] = NUL; + // If the error message has the form "is ...", put the error number in + // front of the file name. + if (errnum != NULL) + { + STRMOVE(IObuff + numlen, IObuff); + mch_memmove(IObuff, errnum, (size_t)numlen); + } + STRCAT(IObuff, errmsg); + emsg((char *)IObuff); + if (errmsg_allocated) + vim_free(errmsg); + + retval = FAIL; + if (end == 0) + { + msg_puts_attr(_("\nWARNING: Original file may be lost or damaged\n"), + attr | MSG_HIST); + msg_puts_attr(_("don't quit the editor until the file is successfully written!"), + attr | MSG_HIST); + + // Update the timestamp to avoid an "overwrite changed file" + // prompt when writing again. + if (mch_stat((char *)fname, &st_old) >= 0) + { + buf_store_time(buf, &st_old, fname); + buf->b_mtime_read = buf->b_mtime; + } + } + } + msg_scroll = msg_save; + +#ifdef FEAT_PERSISTENT_UNDO + // When writing the whole file and 'undofile' is set, also write the undo + // file. + if (retval == OK && write_undo_file) + { + char_u hash[UNDO_HASH_SIZE]; + + sha256_finish(&sha_ctx, hash); + u_write_undo(NULL, FALSE, buf, hash); + } +#endif + +#ifdef FEAT_EVAL + if (!should_abort(retval)) +#else + if (!got_int) +#endif + { + aco_save_T aco; + + curbuf->b_no_eol_lnum = 0; // in case it was set by the previous read + + // Apply POST autocommands. + // Careful: The autocommands may call buf_write() recursively! + aucmd_prepbuf(&aco, buf); + + if (append) + apply_autocmds_exarg(EVENT_FILEAPPENDPOST, fname, fname, + FALSE, curbuf, eap); + else if (filtering) + apply_autocmds_exarg(EVENT_FILTERWRITEPOST, NULL, fname, + FALSE, curbuf, eap); + else if (reset_changed && whole) + apply_autocmds_exarg(EVENT_BUFWRITEPOST, fname, fname, + FALSE, curbuf, eap); + else + apply_autocmds_exarg(EVENT_FILEWRITEPOST, fname, fname, + FALSE, curbuf, eap); + + // restore curwin/curbuf and a few other things + aucmd_restbuf(&aco); + +#ifdef FEAT_EVAL + if (aborting()) // autocmds may abort script processing + retval = FALSE; +#endif + } + + got_int |= prev_got_int; + + return retval; +} diff --git a/src/fileio.c b/src/fileio.c --- a/src/fileio.c +++ b/src/fileio.c @@ -17,13 +17,6 @@ # include /* for SSIZE_MAX */ #endif -#if defined(HAVE_UTIME) && defined(HAVE_UTIME_H) -# include /* for struct utimbuf */ -#endif - -#define BUFSIZE 8192 /* size of normal write buffer */ -#define SMBUFSIZE 256 /* size of emergency write buffer */ - /* Is there any system that doesn't have access()? */ #define USE_MCH_ACCESS @@ -34,84 +27,11 @@ static char_u *readfile_charconvert(char #ifdef FEAT_CRYPT static char_u *check_for_cryptkey(char_u *cryptkey, char_u *ptr, long *sizep, off_T *filesizep, int newfile, char_u *fname, int *did_ask); #endif -static int set_rw_fname(char_u *fname, char_u *sfname); -static int msg_add_fileformat(int eol_type); -static void msg_add_eol(void); -static int check_mtime(buf_T *buf, stat_T *s); -static int time_differs(long t1, long t2); - -#define HAS_BW_FLAGS -#define FIO_LATIN1 0x01 /* convert Latin1 */ -#define FIO_UTF8 0x02 /* convert UTF-8 */ -#define FIO_UCS2 0x04 /* convert UCS-2 */ -#define FIO_UCS4 0x08 /* convert UCS-4 */ -#define FIO_UTF16 0x10 /* convert UTF-16 */ -#ifdef MSWIN -# define FIO_CODEPAGE 0x20 /* convert MS-Windows codepage */ -# define FIO_PUT_CP(x) (((x) & 0xffff) << 16) /* put codepage in top word */ -# define FIO_GET_CP(x) (((x)>>16) & 0xffff) /* get codepage from top word */ -#endif -#ifdef MACOS_CONVERT -# define FIO_MACROMAN 0x20 /* convert MacRoman */ -#endif -#define FIO_ENDIAN_L 0x80 /* little endian */ -#define FIO_ENCRYPTED 0x1000 /* encrypt written bytes */ -#define FIO_NOCONVERT 0x2000 /* skip encoding conversion */ -#define FIO_UCSBOM 0x4000 /* check for BOM at start of file */ -#define FIO_ALL -1 /* allow all formats */ - -/* When converting, a read() or write() may leave some bytes to be converted - * for the next call. The value is guessed... */ -#define CONV_RESTLEN 30 - -/* We have to guess how much a sequence of bytes may expand when converting - * with iconv() to be able to allocate a buffer. */ -#define ICONV_MULT 8 - -/* - * Structure to pass arguments from buf_write() to buf_write_bytes(). - */ -struct bw_info -{ - int bw_fd; /* file descriptor */ - char_u *bw_buf; /* buffer with data to be written */ - int bw_len; /* length of data */ -#ifdef HAS_BW_FLAGS - int bw_flags; /* FIO_ flags */ -#endif -#ifdef FEAT_CRYPT - buf_T *bw_buffer; /* buffer being written */ -#endif - char_u bw_rest[CONV_RESTLEN]; /* not converted bytes */ - int bw_restlen; /* nr of bytes in bw_rest[] */ - int bw_first; /* first write call */ - char_u *bw_conv_buf; /* buffer for writing converted chars */ - size_t bw_conv_buflen; /* size of bw_conv_buf */ - int bw_conv_error; /* set for conversion error */ - linenr_T bw_conv_error_lnum; /* first line with error or zero */ - linenr_T bw_start_lnum; /* line number at start of buffer */ -#ifdef USE_ICONV - iconv_t bw_iconv_fd; /* descriptor for iconv() or -1 */ -#endif -}; - -static int buf_write_bytes(struct bw_info *ip); - static linenr_T readfile_linenr(linenr_T linecnt, char_u *p, char_u *endp); -static int ucs2bytes(unsigned c, char_u **pp, int flags); -static int need_conversion(char_u *fenc); -static int get_fio_flags(char_u *ptr); static char_u *check_for_bom(char_u *p, long size, int *lenp, int flags); -static int make_bom(char_u *buf, char_u *name); -#ifdef MSWIN -static int get_win_fio_flags(char_u *ptr); -#endif -#ifdef MACOS_CONVERT -static int get_mac_fio_flags(char_u *ptr); -#endif static char *e_auchangedbuf = N_("E812: Autocommands changed buffer or buffer name"); - static void + void filemess( buf_T *buf, char_u *name, @@ -119,6 +39,7 @@ filemess( int attr) { int msg_scroll_save; + int prev_msg_col = msg_col; if (msg_silent != 0) return; @@ -138,6 +59,8 @@ filemess( if (!msg_scroll) /* wait a bit when overwriting an error msg */ check_for_delay(FALSE); msg_start(); + if (prev_msg_col != 0 && msg_col == 0) + msg_putchar('\r'); // overwrite any previous message. msg_scroll = msg_scroll_save; msg_scrolled_ign = TRUE; /* may truncate the message to avoid a hit-return prompt */ @@ -2512,7 +2435,11 @@ failed: p = msg_may_trunc(FALSE, IObuff); else #endif + { + if (msg_col > 0) + msg_putchar('\r'); // overwrite previous message p = (char_u *)msg_trunc_attr((char *)IObuff, FALSE, 0); + } if (read_stdin || read_buffer || restart_edit != 0 || (msg_scrolled != 0 && !need_wait_return)) /* Need to repeat the message after redrawing when: @@ -2939,37 +2866,6 @@ check_for_cryptkey( } #endif /* FEAT_CRYPT */ -#ifdef UNIX - static void -set_file_time( - char_u *fname, - time_t atime, /* access time */ - time_t mtime) /* modification time */ -{ -# if defined(HAVE_UTIME) && defined(HAVE_UTIME_H) - struct utimbuf buf; - - buf.actime = atime; - buf.modtime = mtime; - (void)utime((char *)fname, &buf); -# else -# if defined(HAVE_UTIMES) - struct timeval tvp[2]; - - tvp[0].tv_sec = atime; - tvp[0].tv_usec = 0; - tvp[1].tv_sec = mtime; - tvp[1].tv_usec = 0; -# ifdef NeXT - (void)utimes((char *)fname, tvp); -# else - (void)utimes((char *)fname, (const struct timeval *)&tvp); -# endif -# endif -# endif -} -#endif /* UNIX */ - #if defined(VMS) && !defined(MIN) /* Older DECC compiler for VAX doesn't define MIN() */ # define MIN(a, b) ((a) < (b) ? (a) : (b)) @@ -3000,2104 +2896,6 @@ check_file_readonly( ); } - -/* - * buf_write() - write to file "fname" lines "start" through "end" - * - * We do our own buffering here because fwrite() is so slow. - * - * If "forceit" is true, we don't care for errors when attempting backups. - * In case of an error everything possible is done to restore the original - * file. But when "forceit" is TRUE, we risk losing it. - * - * When "reset_changed" is TRUE and "append" == FALSE and "start" == 1 and - * "end" == curbuf->b_ml.ml_line_count, reset curbuf->b_changed. - * - * This function must NOT use NameBuff (because it's called by autowrite()). - * - * return FAIL for failure, OK otherwise - */ - int -buf_write( - buf_T *buf, - char_u *fname, - char_u *sfname, - linenr_T start, - linenr_T end, - exarg_T *eap, /* for forced 'ff' and 'fenc', can be - NULL! */ - int append, /* append to the file */ - int forceit, - int reset_changed, - int filtering) -{ - int fd; - char_u *backup = NULL; - int backup_copy = FALSE; /* copy the original file? */ - int dobackup; - char_u *ffname; - char_u *wfname = NULL; /* name of file to write to */ - char_u *s; - char_u *ptr; - char_u c; - int len; - linenr_T lnum; - long nchars; - char_u *errmsg = NULL; - int errmsg_allocated = FALSE; - char_u *errnum = NULL; - char_u *buffer; - char_u smallbuf[SMBUFSIZE]; - char_u *backup_ext; - int bufsize; - long perm; /* file permissions */ - int retval = OK; - int newfile = FALSE; /* TRUE if file doesn't exist yet */ - int msg_save = msg_scroll; - int overwriting; /* TRUE if writing over original */ - int no_eol = FALSE; /* no end-of-line written */ - int device = FALSE; /* writing to a device */ - stat_T st_old; - int prev_got_int = got_int; - int checking_conversion; - int file_readonly = FALSE; /* overwritten file is read-only */ - static char *err_readonly = "is read-only (cannot override: \"W\" in 'cpoptions')"; -#if defined(UNIX) /*XXX fix me sometime? */ - int made_writable = FALSE; /* 'w' bit has been set */ -#endif - /* writing everything */ - int whole = (start == 1 && end == buf->b_ml.ml_line_count); - linenr_T old_line_count = buf->b_ml.ml_line_count; - int attr; - int fileformat; - int write_bin; - struct bw_info write_info; /* info for buf_write_bytes() */ - int converted = FALSE; - int notconverted = FALSE; - char_u *fenc; /* effective 'fileencoding' */ - char_u *fenc_tofree = NULL; /* allocated "fenc" */ -#ifdef HAS_BW_FLAGS - int wb_flags = 0; -#endif -#ifdef HAVE_ACL - vim_acl_T acl = NULL; /* ACL copied from original file to - backup or new file */ -#endif -#ifdef FEAT_PERSISTENT_UNDO - int write_undo_file = FALSE; - context_sha256_T sha_ctx; -#endif - unsigned int bkc = get_bkc_value(buf); - - if (fname == NULL || *fname == NUL) /* safety check */ - return FAIL; - if (buf->b_ml.ml_mfp == NULL) - { - /* This can happen during startup when there is a stray "w" in the - * vimrc file. */ - emsg(_(e_emptybuf)); - return FAIL; - } - - /* - * Disallow writing from .exrc and .vimrc in current directory for - * security reasons. - */ - if (check_secure()) - return FAIL; - - /* Avoid a crash for a long name. */ - if (STRLEN(fname) >= MAXPATHL) - { - emsg(_(e_longname)); - return FAIL; - } - - /* must init bw_conv_buf and bw_iconv_fd before jumping to "fail" */ - write_info.bw_conv_buf = NULL; - write_info.bw_conv_error = FALSE; - write_info.bw_conv_error_lnum = 0; - write_info.bw_restlen = 0; -#ifdef USE_ICONV - write_info.bw_iconv_fd = (iconv_t)-1; -#endif -#ifdef FEAT_CRYPT - write_info.bw_buffer = buf; -#endif - - /* After writing a file changedtick changes but we don't want to display - * the line. */ - ex_no_reprint = TRUE; - - /* - * If there is no file name yet, use the one for the written file. - * BF_NOTEDITED is set to reflect this (in case the write fails). - * Don't do this when the write is for a filter command. - * Don't do this when appending. - * Only do this when 'cpoptions' contains the 'F' flag. - */ - if (buf->b_ffname == NULL - && reset_changed - && whole - && buf == curbuf -#ifdef FEAT_QUICKFIX - && !bt_nofilename(buf) -#endif - && !filtering - && (!append || vim_strchr(p_cpo, CPO_FNAMEAPP) != NULL) - && vim_strchr(p_cpo, CPO_FNAMEW) != NULL) - { - if (set_rw_fname(fname, sfname) == FAIL) - return FAIL; - buf = curbuf; /* just in case autocmds made "buf" invalid */ - } - - if (sfname == NULL) - sfname = fname; - /* - * For Unix: Use the short file name whenever possible. - * Avoids problems with networks and when directory names are changed. - * Don't do this for MS-DOS, a "cd" in a sub-shell may have moved us to - * another directory, which we don't detect - */ - ffname = fname; /* remember full fname */ -#ifdef UNIX - fname = sfname; -#endif - - if (buf->b_ffname != NULL && fnamecmp(ffname, buf->b_ffname) == 0) - overwriting = TRUE; - else - overwriting = FALSE; - - if (exiting) - settmode(TMODE_COOK); /* when exiting allow typeahead now */ - - ++no_wait_return; /* don't wait for return yet */ - - /* - * Set '[ and '] marks to the lines to be written. - */ - buf->b_op_start.lnum = start; - buf->b_op_start.col = 0; - buf->b_op_end.lnum = end; - buf->b_op_end.col = 0; - - { - aco_save_T aco; - int buf_ffname = FALSE; - int buf_sfname = FALSE; - int buf_fname_f = FALSE; - int buf_fname_s = FALSE; - int did_cmd = FALSE; - int nofile_err = FALSE; - int empty_memline = (buf->b_ml.ml_mfp == NULL); - bufref_T bufref; - - /* - * Apply PRE autocommands. - * Set curbuf to the buffer to be written. - * Careful: The autocommands may call buf_write() recursively! - */ - if (ffname == buf->b_ffname) - buf_ffname = TRUE; - if (sfname == buf->b_sfname) - buf_sfname = TRUE; - if (fname == buf->b_ffname) - buf_fname_f = TRUE; - if (fname == buf->b_sfname) - buf_fname_s = TRUE; - - /* set curwin/curbuf to buf and save a few things */ - aucmd_prepbuf(&aco, buf); - set_bufref(&bufref, buf); - - if (append) - { - if (!(did_cmd = apply_autocmds_exarg(EVENT_FILEAPPENDCMD, - sfname, sfname, FALSE, curbuf, eap))) - { -#ifdef FEAT_QUICKFIX - if (overwriting && bt_nofilename(curbuf)) - nofile_err = TRUE; - else -#endif - apply_autocmds_exarg(EVENT_FILEAPPENDPRE, - sfname, sfname, FALSE, curbuf, eap); - } - } - else if (filtering) - { - apply_autocmds_exarg(EVENT_FILTERWRITEPRE, - NULL, sfname, FALSE, curbuf, eap); - } - else if (reset_changed && whole) - { - int was_changed = curbufIsChanged(); - - did_cmd = apply_autocmds_exarg(EVENT_BUFWRITECMD, - sfname, sfname, FALSE, curbuf, eap); - if (did_cmd) - { - if (was_changed && !curbufIsChanged()) - { - /* Written everything correctly and BufWriteCmd has reset - * 'modified': Correct the undo information so that an - * undo now sets 'modified'. */ - u_unchanged(curbuf); - u_update_save_nr(curbuf); - } - } - else - { -#ifdef FEAT_QUICKFIX - if (overwriting && bt_nofilename(curbuf)) - nofile_err = TRUE; - else -#endif - apply_autocmds_exarg(EVENT_BUFWRITEPRE, - sfname, sfname, FALSE, curbuf, eap); - } - } - else - { - if (!(did_cmd = apply_autocmds_exarg(EVENT_FILEWRITECMD, - sfname, sfname, FALSE, curbuf, eap))) - { -#ifdef FEAT_QUICKFIX - if (overwriting && bt_nofilename(curbuf)) - nofile_err = TRUE; - else -#endif - apply_autocmds_exarg(EVENT_FILEWRITEPRE, - sfname, sfname, FALSE, curbuf, eap); - } - } - - /* restore curwin/curbuf and a few other things */ - aucmd_restbuf(&aco); - - /* - * In three situations we return here and don't write the file: - * 1. the autocommands deleted or unloaded the buffer. - * 2. The autocommands abort script processing. - * 3. If one of the "Cmd" autocommands was executed. - */ - if (!bufref_valid(&bufref)) - buf = NULL; - if (buf == NULL || (buf->b_ml.ml_mfp == NULL && !empty_memline) - || did_cmd || nofile_err -#ifdef FEAT_EVAL - || aborting() -#endif - ) - { - --no_wait_return; - msg_scroll = msg_save; - if (nofile_err) - emsg(_("E676: No matching autocommands for acwrite buffer")); - - if (nofile_err -#ifdef FEAT_EVAL - || aborting() -#endif - ) - /* An aborting error, interrupt or exception in the - * autocommands. */ - return FAIL; - if (did_cmd) - { - if (buf == NULL) - /* The buffer was deleted. We assume it was written - * (can't retry anyway). */ - return OK; - if (overwriting) - { - /* Assume the buffer was written, update the timestamp. */ - ml_timestamp(buf); - if (append) - buf->b_flags &= ~BF_NEW; - else - buf->b_flags &= ~BF_WRITE_MASK; - } - if (reset_changed && buf->b_changed && !append - && (overwriting || vim_strchr(p_cpo, CPO_PLUS) != NULL)) - /* Buffer still changed, the autocommands didn't work - * properly. */ - return FAIL; - return OK; - } -#ifdef FEAT_EVAL - if (!aborting()) -#endif - emsg(_("E203: Autocommands deleted or unloaded buffer to be written")); - return FAIL; - } - - /* - * The autocommands may have changed the number of lines in the file. - * When writing the whole file, adjust the end. - * When writing part of the file, assume that the autocommands only - * changed the number of lines that are to be written (tricky!). - */ - if (buf->b_ml.ml_line_count != old_line_count) - { - if (whole) /* write all */ - end = buf->b_ml.ml_line_count; - else if (buf->b_ml.ml_line_count > old_line_count) /* more lines */ - end += buf->b_ml.ml_line_count - old_line_count; - else /* less lines */ - { - end -= old_line_count - buf->b_ml.ml_line_count; - if (end < start) - { - --no_wait_return; - msg_scroll = msg_save; - emsg(_("E204: Autocommand changed number of lines in unexpected way")); - return FAIL; - } - } - } - - /* - * The autocommands may have changed the name of the buffer, which may - * be kept in fname, ffname and sfname. - */ - if (buf_ffname) - ffname = buf->b_ffname; - if (buf_sfname) - sfname = buf->b_sfname; - if (buf_fname_f) - fname = buf->b_ffname; - if (buf_fname_s) - fname = buf->b_sfname; - } - -#ifdef FEAT_NETBEANS_INTG - if (netbeans_active() && isNetbeansBuffer(buf)) - { - if (whole) - { - /* - * b_changed can be 0 after an undo, but we still need to write - * the buffer to NetBeans. - */ - if (buf->b_changed || isNetbeansModified(buf)) - { - --no_wait_return; /* may wait for return now */ - msg_scroll = msg_save; - netbeans_save_buffer(buf); /* no error checking... */ - return retval; - } - else - { - errnum = (char_u *)"E656: "; - errmsg = (char_u *)_("NetBeans disallows writes of unmodified buffers"); - buffer = NULL; - goto fail; - } - } - else - { - errnum = (char_u *)"E657: "; - errmsg = (char_u *)_("Partial writes disallowed for NetBeans buffers"); - buffer = NULL; - goto fail; - } - } -#endif - - if (shortmess(SHM_OVER) && !exiting) - msg_scroll = FALSE; /* overwrite previous file message */ - else - msg_scroll = TRUE; /* don't overwrite previous file message */ - if (!filtering) - filemess(buf, -#ifndef UNIX - sfname, -#else - fname, -#endif - (char_u *)"", 0); /* show that we are busy */ - msg_scroll = FALSE; /* always overwrite the file message now */ - - buffer = alloc(BUFSIZE); - if (buffer == NULL) /* can't allocate big buffer, use small - * one (to be able to write when out of - * memory) */ - { - buffer = smallbuf; - bufsize = SMBUFSIZE; - } - else - bufsize = BUFSIZE; - - /* - * Get information about original file (if there is one). - */ -#if defined(UNIX) - st_old.st_dev = 0; - st_old.st_ino = 0; - perm = -1; - if (mch_stat((char *)fname, &st_old) < 0) - newfile = TRUE; - else - { - perm = st_old.st_mode; - if (!S_ISREG(st_old.st_mode)) /* not a file */ - { - if (S_ISDIR(st_old.st_mode)) - { - errnum = (char_u *)"E502: "; - errmsg = (char_u *)_("is a directory"); - goto fail; - } - if (mch_nodetype(fname) != NODE_WRITABLE) - { - errnum = (char_u *)"E503: "; - errmsg = (char_u *)_("is not a file or writable device"); - goto fail; - } - /* It's a device of some kind (or a fifo) which we can write to - * but for which we can't make a backup. */ - device = TRUE; - newfile = TRUE; - perm = -1; - } - } -#else /* !UNIX */ - /* - * Check for a writable device name. - */ - c = mch_nodetype(fname); - if (c == NODE_OTHER) - { - errnum = (char_u *)"E503: "; - errmsg = (char_u *)_("is not a file or writable device"); - goto fail; - } - if (c == NODE_WRITABLE) - { -# if defined(MSWIN) - /* MS-Windows allows opening a device, but we will probably get stuck - * trying to write to it. */ - if (!p_odev) - { - errnum = (char_u *)"E796: "; - errmsg = (char_u *)_("writing to device disabled with 'opendevice' option"); - goto fail; - } -# endif - device = TRUE; - newfile = TRUE; - perm = -1; - } - else - { - perm = mch_getperm(fname); - if (perm < 0) - newfile = TRUE; - else if (mch_isdir(fname)) - { - errnum = (char_u *)"E502: "; - errmsg = (char_u *)_("is a directory"); - goto fail; - } - if (overwriting) - (void)mch_stat((char *)fname, &st_old); - } -#endif /* !UNIX */ - - if (!device && !newfile) - { - /* - * Check if the file is really writable (when renaming the file to - * make a backup we won't discover it later). - */ - file_readonly = check_file_readonly(fname, (int)perm); - - if (!forceit && file_readonly) - { - if (vim_strchr(p_cpo, CPO_FWRITE) != NULL) - { - errnum = (char_u *)"E504: "; - errmsg = (char_u *)_(err_readonly); - } - else - { - errnum = (char_u *)"E505: "; - errmsg = (char_u *)_("is read-only (add ! to override)"); - } - goto fail; - } - - /* - * Check if the timestamp hasn't changed since reading the file. - */ - if (overwriting) - { - retval = check_mtime(buf, &st_old); - if (retval == FAIL) - goto fail; - } - } - -#ifdef HAVE_ACL - /* - * For systems that support ACL: get the ACL from the original file. - */ - if (!newfile) - acl = mch_get_acl(fname); -#endif - - /* - * If 'backupskip' is not empty, don't make a backup for some files. - */ - dobackup = (p_wb || p_bk || *p_pm != NUL); -#ifdef FEAT_WILDIGN - if (dobackup && *p_bsk != NUL && match_file_list(p_bsk, sfname, ffname)) - dobackup = FALSE; -#endif - - /* - * Save the value of got_int and reset it. We don't want a previous - * interruption cancel writing, only hitting CTRL-C while writing should - * abort it. - */ - prev_got_int = got_int; - got_int = FALSE; - - /* Mark the buffer as 'being saved' to prevent changed buffer warnings */ - buf->b_saving = TRUE; - - /* - * If we are not appending or filtering, the file exists, and the - * 'writebackup', 'backup' or 'patchmode' option is set, need a backup. - * When 'patchmode' is set also make a backup when appending. - * - * Do not make any backup, if 'writebackup' and 'backup' are both switched - * off. This helps when editing large files on almost-full disks. - */ - if (!(append && *p_pm == NUL) && !filtering && perm >= 0 && dobackup) - { -#if defined(UNIX) || defined(MSWIN) - stat_T st; -#endif - - if ((bkc & BKC_YES) || append) /* "yes" */ - backup_copy = TRUE; -#if defined(UNIX) || defined(MSWIN) - else if ((bkc & BKC_AUTO)) /* "auto" */ - { - int i; - -# ifdef UNIX - /* - * Don't rename the file when: - * - it's a hard link - * - it's a symbolic link - * - we don't have write permission in the directory - * - we can't set the owner/group of the new file - */ - if (st_old.st_nlink > 1 - || mch_lstat((char *)fname, &st) < 0 - || st.st_dev != st_old.st_dev - || st.st_ino != st_old.st_ino -# ifndef HAVE_FCHOWN - || st.st_uid != st_old.st_uid - || st.st_gid != st_old.st_gid -# endif - ) - backup_copy = TRUE; - else -# else -# ifdef MSWIN - /* On NTFS file systems hard links are possible. */ - if (mch_is_linked(fname)) - backup_copy = TRUE; - else -# endif -# endif - { - /* - * Check if we can create a file and set the owner/group to - * the ones from the original file. - * First find a file name that doesn't exist yet (use some - * arbitrary numbers). - */ - STRCPY(IObuff, fname); - for (i = 4913; ; i += 123) - { - sprintf((char *)gettail(IObuff), "%d", i); - if (mch_lstat((char *)IObuff, &st) < 0) - break; - } - fd = mch_open((char *)IObuff, - O_CREAT|O_WRONLY|O_EXCL|O_NOFOLLOW, perm); - if (fd < 0) /* can't write in directory */ - backup_copy = TRUE; - else - { -# ifdef UNIX -# ifdef HAVE_FCHOWN - vim_ignored = fchown(fd, st_old.st_uid, st_old.st_gid); -# endif - if (mch_stat((char *)IObuff, &st) < 0 - || st.st_uid != st_old.st_uid - || st.st_gid != st_old.st_gid - || (long)st.st_mode != perm) - backup_copy = TRUE; -# endif - /* Close the file before removing it, on MS-Windows we - * can't delete an open file. */ - close(fd); - mch_remove(IObuff); -# ifdef MSWIN - /* MS-Windows may trigger a virus scanner to open the - * file, we can't delete it then. Keep trying for half a - * second. */ - { - int try; - - for (try = 0; try < 10; ++try) - { - if (mch_lstat((char *)IObuff, &st) < 0) - break; - ui_delay(50L, TRUE); /* wait 50 msec */ - mch_remove(IObuff); - } - } -# endif - } - } - } - - /* - * Break symlinks and/or hardlinks if we've been asked to. - */ - if ((bkc & BKC_BREAKSYMLINK) || (bkc & BKC_BREAKHARDLINK)) - { -# ifdef UNIX - int lstat_res; - - lstat_res = mch_lstat((char *)fname, &st); - - /* Symlinks. */ - if ((bkc & BKC_BREAKSYMLINK) - && lstat_res == 0 - && st.st_ino != st_old.st_ino) - backup_copy = FALSE; - - /* Hardlinks. */ - if ((bkc & BKC_BREAKHARDLINK) - && st_old.st_nlink > 1 - && (lstat_res != 0 || st.st_ino == st_old.st_ino)) - backup_copy = FALSE; -# else -# if defined(MSWIN) - /* Symlinks. */ - if ((bkc & BKC_BREAKSYMLINK) && mch_is_symbolic_link(fname)) - backup_copy = FALSE; - - /* Hardlinks. */ - if ((bkc & BKC_BREAKHARDLINK) && mch_is_hard_link(fname)) - backup_copy = FALSE; -# endif -# endif - } - -#endif - - /* make sure we have a valid backup extension to use */ - if (*p_bex == NUL) - backup_ext = (char_u *)".bak"; - else - backup_ext = p_bex; - - if (backup_copy - && (fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0)) >= 0) - { - int bfd; - char_u *copybuf, *wp; - int some_error = FALSE; - stat_T st_new; - char_u *dirp; - char_u *rootname; -#if defined(UNIX) || defined(MSWIN) - char_u *p; -#endif -#if defined(UNIX) - int did_set_shortname; - mode_t umask_save; -#endif - - copybuf = alloc(BUFSIZE + 1); - if (copybuf == NULL) - { - some_error = TRUE; /* out of memory */ - goto nobackup; - } - - /* - * Try to make the backup in each directory in the 'bdir' option. - * - * Unix semantics has it, that we may have a writable file, - * that cannot be recreated with a simple open(..., O_CREAT, ) e.g: - * - the directory is not writable, - * - the file may be a symbolic link, - * - the file may belong to another user/group, etc. - * - * For these reasons, the existing writable file must be truncated - * and reused. Creation of a backup COPY will be attempted. - */ - dirp = p_bdir; - while (*dirp) - { -#ifdef UNIX - st_new.st_ino = 0; - st_new.st_dev = 0; - st_new.st_gid = 0; -#endif - - /* - * Isolate one directory name, using an entry in 'bdir'. - */ - (void)copy_option_part(&dirp, copybuf, BUFSIZE, ","); - -#if defined(UNIX) || defined(MSWIN) - p = copybuf + STRLEN(copybuf); - if (after_pathsep(copybuf, p) && p[-1] == p[-2]) - // Ends with '//', use full path - if ((p = make_percent_swname(copybuf, fname)) != NULL) - { - backup = modname(p, backup_ext, FALSE); - vim_free(p); - } -#endif - rootname = get_file_in_dir(fname, copybuf); - if (rootname == NULL) - { - some_error = TRUE; /* out of memory */ - goto nobackup; - } - -#if defined(UNIX) - did_set_shortname = FALSE; -#endif - - /* - * May try twice if 'shortname' not set. - */ - for (;;) - { - /* - * Make the backup file name. - */ - if (backup == NULL) - backup = buf_modname((buf->b_p_sn || buf->b_shortname), - rootname, backup_ext, FALSE); - if (backup == NULL) - { - vim_free(rootname); - some_error = TRUE; /* out of memory */ - goto nobackup; - } - - /* - * Check if backup file already exists. - */ - if (mch_stat((char *)backup, &st_new) >= 0) - { -#ifdef UNIX - /* - * Check if backup file is same as original file. - * May happen when modname() gave the same file back. - * E.g. silly link, or file name-length reached. - * If we don't check here, we either ruin the file - * when copying or erase it after writing. jw. - */ - if (st_new.st_dev == st_old.st_dev - && st_new.st_ino == st_old.st_ino) - { - VIM_CLEAR(backup); /* no backup file to delete */ - /* - * may try again with 'shortname' set - */ - if (!(buf->b_shortname || buf->b_p_sn)) - { - buf->b_shortname = TRUE; - did_set_shortname = TRUE; - continue; - } - /* setting shortname didn't help */ - if (did_set_shortname) - buf->b_shortname = FALSE; - break; - } -#endif - - /* - * If we are not going to keep the backup file, don't - * delete an existing one, try to use another name. - * Change one character, just before the extension. - */ - if (!p_bk) - { - wp = backup + STRLEN(backup) - 1 - - STRLEN(backup_ext); - if (wp < backup) /* empty file name ??? */ - wp = backup; - *wp = 'z'; - while (*wp > 'a' - && mch_stat((char *)backup, &st_new) >= 0) - --*wp; - /* They all exist??? Must be something wrong. */ - if (*wp == 'a') - VIM_CLEAR(backup); - } - } - break; - } - vim_free(rootname); - - /* - * Try to create the backup file - */ - if (backup != NULL) - { - /* remove old backup, if present */ - mch_remove(backup); - /* Open with O_EXCL to avoid the file being created while - * we were sleeping (symlink hacker attack?). Reset umask - * if possible to avoid mch_setperm() below. */ -#ifdef UNIX - umask_save = umask(0); -#endif - bfd = mch_open((char *)backup, - O_WRONLY|O_CREAT|O_EXTRA|O_EXCL|O_NOFOLLOW, - perm & 0777); -#ifdef UNIX - (void)umask(umask_save); -#endif - if (bfd < 0) - VIM_CLEAR(backup); - else - { - /* Set file protection same as original file, but - * strip s-bit. Only needed if umask() wasn't used - * above. */ -#ifndef UNIX - (void)mch_setperm(backup, perm & 0777); -#else - /* - * Try to set the group of the backup same as the - * original file. If this fails, set the protection - * bits for the group same as the protection bits for - * others. - */ - if (st_new.st_gid != st_old.st_gid -# ifdef HAVE_FCHOWN /* sequent-ptx lacks fchown() */ - && fchown(bfd, (uid_t)-1, st_old.st_gid) != 0 -# endif - ) - mch_setperm(backup, - (perm & 0707) | ((perm & 07) << 3)); -# if defined(HAVE_SELINUX) || defined(HAVE_SMACK) - mch_copy_sec(fname, backup); -# endif -#endif - - /* - * copy the file. - */ - write_info.bw_fd = bfd; - write_info.bw_buf = copybuf; -#ifdef HAS_BW_FLAGS - write_info.bw_flags = FIO_NOCONVERT; -#endif - while ((write_info.bw_len = read_eintr(fd, copybuf, - BUFSIZE)) > 0) - { - if (buf_write_bytes(&write_info) == FAIL) - { - errmsg = (char_u *)_("E506: Can't write to backup file (add ! to override)"); - break; - } - ui_breakcheck(); - if (got_int) - { - errmsg = (char_u *)_(e_interr); - break; - } - } - - if (close(bfd) < 0 && errmsg == NULL) - errmsg = (char_u *)_("E507: Close error for backup file (add ! to override)"); - if (write_info.bw_len < 0) - errmsg = (char_u *)_("E508: Can't read file for backup (add ! to override)"); -#ifdef UNIX - set_file_time(backup, st_old.st_atime, st_old.st_mtime); -#endif -#ifdef HAVE_ACL - mch_set_acl(backup, acl); -#endif -#if defined(HAVE_SELINUX) || defined(HAVE_SMACK) - mch_copy_sec(fname, backup); -#endif - break; - } - } - } - nobackup: - close(fd); /* ignore errors for closing read file */ - vim_free(copybuf); - - if (backup == NULL && errmsg == NULL) - errmsg = (char_u *)_("E509: Cannot create backup file (add ! to override)"); - /* ignore errors when forceit is TRUE */ - if ((some_error || errmsg != NULL) && !forceit) - { - retval = FAIL; - goto fail; - } - errmsg = NULL; - } - else - { - char_u *dirp; - char_u *p; - char_u *rootname; - - /* - * Make a backup by renaming the original file. - */ - /* - * If 'cpoptions' includes the "W" flag, we don't want to - * overwrite a read-only file. But rename may be possible - * anyway, thus we need an extra check here. - */ - if (file_readonly && vim_strchr(p_cpo, CPO_FWRITE) != NULL) - { - errnum = (char_u *)"E504: "; - errmsg = (char_u *)_(err_readonly); - goto fail; - } - - /* - * - * Form the backup file name - change path/fo.o.h to - * path/fo.o.h.bak Try all directories in 'backupdir', first one - * that works is used. - */ - dirp = p_bdir; - while (*dirp) - { - /* - * Isolate one directory name and make the backup file name. - */ - (void)copy_option_part(&dirp, IObuff, IOSIZE, ","); - -#if defined(UNIX) || defined(MSWIN) - p = IObuff + STRLEN(IObuff); - if (after_pathsep(IObuff, p) && p[-1] == p[-2]) - // path ends with '//', use full path - if ((p = make_percent_swname(IObuff, fname)) != NULL) - { - backup = modname(p, backup_ext, FALSE); - vim_free(p); - } -#endif - if (backup == NULL) - { - rootname = get_file_in_dir(fname, IObuff); - if (rootname == NULL) - backup = NULL; - else - { - backup = buf_modname( - (buf->b_p_sn || buf->b_shortname), - rootname, backup_ext, FALSE); - vim_free(rootname); - } - } - - if (backup != NULL) - { - /* - * If we are not going to keep the backup file, don't - * delete an existing one, try to use another name. - * Change one character, just before the extension. - */ - if (!p_bk && mch_getperm(backup) >= 0) - { - p = backup + STRLEN(backup) - 1 - STRLEN(backup_ext); - if (p < backup) /* empty file name ??? */ - p = backup; - *p = 'z'; - while (*p > 'a' && mch_getperm(backup) >= 0) - --*p; - /* They all exist??? Must be something wrong! */ - if (*p == 'a') - VIM_CLEAR(backup); - } - } - if (backup != NULL) - { - /* - * Delete any existing backup and move the current version - * to the backup. For safety, we don't remove the backup - * until the write has finished successfully. And if the - * 'backup' option is set, leave it around. - */ - /* - * If the renaming of the original file to the backup file - * works, quit here. - */ - if (vim_rename(fname, backup) == 0) - break; - - VIM_CLEAR(backup); /* don't do the rename below */ - } - } - if (backup == NULL && !forceit) - { - errmsg = (char_u *)_("E510: Can't make backup file (add ! to override)"); - goto fail; - } - } - } - -#if defined(UNIX) - /* When using ":w!" and the file was read-only: make it writable */ - if (forceit && perm >= 0 && !(perm & 0200) && st_old.st_uid == getuid() - && vim_strchr(p_cpo, CPO_FWRITE) == NULL) - { - perm |= 0200; - (void)mch_setperm(fname, perm); - made_writable = TRUE; - } -#endif - - /* When using ":w!" and writing to the current file, 'readonly' makes no - * sense, reset it, unless 'Z' appears in 'cpoptions'. */ - if (forceit && overwriting && vim_strchr(p_cpo, CPO_KEEPRO) == NULL) - { - buf->b_p_ro = FALSE; -#ifdef FEAT_TITLE - need_maketitle = TRUE; /* set window title later */ -#endif - status_redraw_all(); /* redraw status lines later */ - } - - if (end > buf->b_ml.ml_line_count) - end = buf->b_ml.ml_line_count; - if (buf->b_ml.ml_flags & ML_EMPTY) - start = end + 1; - - /* - * If the original file is being overwritten, there is a small chance that - * we crash in the middle of writing. Therefore the file is preserved now. - * This makes all block numbers positive so that recovery does not need - * the original file. - * Don't do this if there is a backup file and we are exiting. - */ - if (reset_changed && !newfile && overwriting - && !(exiting && backup != NULL)) - { - ml_preserve(buf, FALSE); - if (got_int) - { - errmsg = (char_u *)_(e_interr); - goto restore_backup; - } - } - -#ifdef VMS - vms_remove_version(fname); /* remove version */ -#endif - /* Default: write the file directly. May write to a temp file for - * multi-byte conversion. */ - wfname = fname; - - /* Check for forced 'fileencoding' from "++opt=val" argument. */ - if (eap != NULL && eap->force_enc != 0) - { - fenc = eap->cmd + eap->force_enc; - fenc = enc_canonize(fenc); - fenc_tofree = fenc; - } - else - fenc = buf->b_p_fenc; - - /* - * Check if the file needs to be converted. - */ - converted = need_conversion(fenc); - - /* - * Check if UTF-8 to UCS-2/4 or Latin1 conversion needs to be done. Or - * Latin1 to Unicode conversion. This is handled in buf_write_bytes(). - * Prepare the flags for it and allocate bw_conv_buf when needed. - */ - if (converted && (enc_utf8 || STRCMP(p_enc, "latin1") == 0)) - { - wb_flags = get_fio_flags(fenc); - if (wb_flags & (FIO_UCS2 | FIO_UCS4 | FIO_UTF16 | FIO_UTF8)) - { - /* Need to allocate a buffer to translate into. */ - if (wb_flags & (FIO_UCS2 | FIO_UTF16 | FIO_UTF8)) - write_info.bw_conv_buflen = bufsize * 2; - else /* FIO_UCS4 */ - write_info.bw_conv_buflen = bufsize * 4; - write_info.bw_conv_buf = alloc(write_info.bw_conv_buflen); - if (write_info.bw_conv_buf == NULL) - end = 0; - } - } - -#ifdef MSWIN - if (converted && wb_flags == 0 && (wb_flags = get_win_fio_flags(fenc)) != 0) - { - /* Convert UTF-8 -> UCS-2 and UCS-2 -> DBCS. Worst-case * 4: */ - write_info.bw_conv_buflen = bufsize * 4; - write_info.bw_conv_buf = alloc(write_info.bw_conv_buflen); - if (write_info.bw_conv_buf == NULL) - end = 0; - } -#endif - -#ifdef MACOS_CONVERT - if (converted && wb_flags == 0 && (wb_flags = get_mac_fio_flags(fenc)) != 0) - { - write_info.bw_conv_buflen = bufsize * 3; - write_info.bw_conv_buf = alloc(write_info.bw_conv_buflen); - if (write_info.bw_conv_buf == NULL) - end = 0; - } -#endif - -#if defined(FEAT_EVAL) || defined(USE_ICONV) - if (converted && wb_flags == 0) - { -# ifdef USE_ICONV - /* - * Use iconv() conversion when conversion is needed and it's not done - * internally. - */ - write_info.bw_iconv_fd = (iconv_t)my_iconv_open(fenc, - enc_utf8 ? (char_u *)"utf-8" : p_enc); - if (write_info.bw_iconv_fd != (iconv_t)-1) - { - /* We're going to use iconv(), allocate a buffer to convert in. */ - write_info.bw_conv_buflen = bufsize * ICONV_MULT; - write_info.bw_conv_buf = alloc(write_info.bw_conv_buflen); - if (write_info.bw_conv_buf == NULL) - end = 0; - write_info.bw_first = TRUE; - } -# ifdef FEAT_EVAL - else -# endif -# endif - -# ifdef FEAT_EVAL - /* - * When the file needs to be converted with 'charconvert' after - * writing, write to a temp file instead and let the conversion - * overwrite the original file. - */ - if (*p_ccv != NUL) - { - wfname = vim_tempname('w', FALSE); - if (wfname == NULL) /* Can't write without a tempfile! */ - { - errmsg = (char_u *)_("E214: Can't find temp file for writing"); - goto restore_backup; - } - } -# endif - } -#endif - if (converted && wb_flags == 0 -#ifdef USE_ICONV - && write_info.bw_iconv_fd == (iconv_t)-1 -# endif -# ifdef FEAT_EVAL - && wfname == fname -# endif - ) - { - if (!forceit) - { - errmsg = (char_u *)_("E213: Cannot convert (add ! to write without conversion)"); - goto restore_backup; - } - notconverted = TRUE; - } - - /* - * If conversion is taking place, we may first pretend to write and check - * for conversion errors. Then loop again to write for real. - * When not doing conversion this writes for real right away. - */ - for (checking_conversion = TRUE; ; checking_conversion = FALSE) - { - /* - * There is no need to check conversion when: - * - there is no conversion - * - we make a backup file, that can be restored in case of conversion - * failure. - */ - if (!converted || dobackup) - checking_conversion = FALSE; - - if (checking_conversion) - { - /* Make sure we don't write anything. */ - fd = -1; - write_info.bw_fd = fd; - } - else - { -#ifdef HAVE_FTRUNCATE -# define TRUNC_ON_OPEN 0 -#else -# define TRUNC_ON_OPEN O_TRUNC -#endif - /* - * Open the file "wfname" for writing. - * We may try to open the file twice: If we can't write to the file - * and forceit is TRUE we delete the existing file and try to - * create a new one. If this still fails we may have lost the - * original file! (this may happen when the user reached his - * quotum for number of files). - * Appending will fail if the file does not exist and forceit is - * FALSE. - */ - while ((fd = mch_open((char *)wfname, O_WRONLY | O_EXTRA | (append - ? (forceit ? (O_APPEND | O_CREAT) : O_APPEND) - : (O_CREAT | TRUNC_ON_OPEN)) - , perm < 0 ? 0666 : (perm & 0777))) < 0) - { - /* - * A forced write will try to create a new file if the old one - * is still readonly. This may also happen when the directory - * is read-only. In that case the mch_remove() will fail. - */ - if (errmsg == NULL) - { -#ifdef UNIX - stat_T st; - - /* Don't delete the file when it's a hard or symbolic link. - */ - if ((!newfile && st_old.st_nlink > 1) - || (mch_lstat((char *)fname, &st) == 0 - && (st.st_dev != st_old.st_dev - || st.st_ino != st_old.st_ino))) - errmsg = (char_u *)_("E166: Can't open linked file for writing"); - else -#endif - { - errmsg = (char_u *)_("E212: Can't open file for writing"); - if (forceit && vim_strchr(p_cpo, CPO_FWRITE) == NULL - && perm >= 0) - { -#ifdef UNIX - /* we write to the file, thus it should be marked - writable after all */ - if (!(perm & 0200)) - made_writable = TRUE; - perm |= 0200; - if (st_old.st_uid != getuid() - || st_old.st_gid != getgid()) - perm &= 0777; -#endif - if (!append) /* don't remove when appending */ - mch_remove(wfname); - continue; - } - } - } - -restore_backup: - { - stat_T st; - - /* - * If we failed to open the file, we don't need a backup. - * Throw it away. If we moved or removed the original file - * try to put the backup in its place. - */ - if (backup != NULL && wfname == fname) - { - if (backup_copy) - { - /* - * There is a small chance that we removed the - * original, try to move the copy in its place. - * This may not work if the vim_rename() fails. - * In that case we leave the copy around. - */ - /* If file does not exist, put the copy in its - * place */ - if (mch_stat((char *)fname, &st) < 0) - vim_rename(backup, fname); - /* if original file does exist throw away the copy - */ - if (mch_stat((char *)fname, &st) >= 0) - mch_remove(backup); - } - else - { - /* try to put the original file back */ - vim_rename(backup, fname); - } - } - - /* if original file no longer exists give an extra warning - */ - if (!newfile && mch_stat((char *)fname, &st) < 0) - end = 0; - } - - if (wfname != fname) - vim_free(wfname); - goto fail; - } - write_info.bw_fd = fd; - -#if defined(UNIX) - { - stat_T st; - - /* Double check we are writing the intended file before making - * any changes. */ - if (overwriting - && (!dobackup || backup_copy) - && fname == wfname - && perm >= 0 - && mch_fstat(fd, &st) == 0 - && st.st_ino != st_old.st_ino) - { - close(fd); - errmsg = (char_u *)_("E949: File changed while writing"); - goto fail; - } - } -#endif -#ifdef HAVE_FTRUNCATE - if (!append) - vim_ignored = ftruncate(fd, (off_t)0); -#endif - -#if defined(MSWIN) - if (backup != NULL && overwriting && !append) - { - if (backup_copy) - (void)mch_copy_file_attribute(wfname, backup); - else - (void)mch_copy_file_attribute(backup, wfname); - } - - if (!overwriting && !append) - { - if (buf->b_ffname != NULL) - (void)mch_copy_file_attribute(buf->b_ffname, wfname); - /* Should copy resource fork */ - } -#endif - -#ifdef FEAT_CRYPT - if (*buf->b_p_key != NUL && !filtering) - { - char_u *header; - int header_len; - - buf->b_cryptstate = crypt_create_for_writing( - crypt_get_method_nr(buf), - buf->b_p_key, &header, &header_len); - if (buf->b_cryptstate == NULL || header == NULL) - end = 0; - else - { - /* Write magic number, so that Vim knows how this file is - * encrypted when reading it back. */ - write_info.bw_buf = header; - write_info.bw_len = header_len; - write_info.bw_flags = FIO_NOCONVERT; - if (buf_write_bytes(&write_info) == FAIL) - end = 0; - wb_flags |= FIO_ENCRYPTED; - vim_free(header); - } - } -#endif - } - errmsg = NULL; - - write_info.bw_buf = buffer; - nchars = 0; - - /* use "++bin", "++nobin" or 'binary' */ - if (eap != NULL && eap->force_bin != 0) - write_bin = (eap->force_bin == FORCE_BIN); - else - write_bin = buf->b_p_bin; - - /* - * The BOM is written just after the encryption magic number. - * Skip it when appending and the file already existed, the BOM only - * makes sense at the start of the file. - */ - if (buf->b_p_bomb && !write_bin && (!append || perm < 0)) - { - write_info.bw_len = make_bom(buffer, fenc); - if (write_info.bw_len > 0) - { - /* don't convert, do encryption */ - write_info.bw_flags = FIO_NOCONVERT | wb_flags; - if (buf_write_bytes(&write_info) == FAIL) - end = 0; - else - nchars += write_info.bw_len; - } - } - write_info.bw_start_lnum = start; - -#ifdef FEAT_PERSISTENT_UNDO - write_undo_file = (buf->b_p_udf - && overwriting - && !append - && !filtering - && reset_changed - && !checking_conversion); - if (write_undo_file) - /* Prepare for computing the hash value of the text. */ - sha256_start(&sha_ctx); -#endif - - write_info.bw_len = bufsize; -#ifdef HAS_BW_FLAGS - write_info.bw_flags = wb_flags; -#endif - fileformat = get_fileformat_force(buf, eap); - s = buffer; - len = 0; - for (lnum = start; lnum <= end; ++lnum) - { - /* - * The next while loop is done once for each character written. - * Keep it fast! - */ - ptr = ml_get_buf(buf, lnum, FALSE) - 1; -#ifdef FEAT_PERSISTENT_UNDO - if (write_undo_file) - sha256_update(&sha_ctx, ptr + 1, - (UINT32_T)(STRLEN(ptr + 1) + 1)); -#endif - while ((c = *++ptr) != NUL) - { - if (c == NL) - *s = NUL; /* replace newlines with NULs */ - else if (c == CAR && fileformat == EOL_MAC) - *s = NL; /* Mac: replace CRs with NLs */ - else - *s = c; - ++s; - if (++len != bufsize) - continue; - if (buf_write_bytes(&write_info) == FAIL) - { - end = 0; /* write error: break loop */ - break; - } - nchars += bufsize; - s = buffer; - len = 0; - write_info.bw_start_lnum = lnum; - } - /* write failed or last line has no EOL: stop here */ - if (end == 0 - || (lnum == end - && (write_bin || !buf->b_p_fixeol) - && (lnum == buf->b_no_eol_lnum - || (lnum == buf->b_ml.ml_line_count - && !buf->b_p_eol)))) - { - ++lnum; /* written the line, count it */ - no_eol = TRUE; - break; - } - if (fileformat == EOL_UNIX) - *s++ = NL; - else - { - *s++ = CAR; /* EOL_MAC or EOL_DOS: write CR */ - if (fileformat == EOL_DOS) /* write CR-NL */ - { - if (++len == bufsize) - { - if (buf_write_bytes(&write_info) == FAIL) - { - end = 0; /* write error: break loop */ - break; - } - nchars += bufsize; - s = buffer; - len = 0; - } - *s++ = NL; - } - } - if (++len == bufsize && end) - { - if (buf_write_bytes(&write_info) == FAIL) - { - end = 0; /* write error: break loop */ - break; - } - nchars += bufsize; - s = buffer; - len = 0; - - ui_breakcheck(); - if (got_int) - { - end = 0; /* Interrupted, break loop */ - break; - } - } -#ifdef VMS - /* - * On VMS there is a problem: newlines get added when writing - * blocks at a time. Fix it by writing a line at a time. - * This is much slower! - * Explanation: VAX/DECC RTL insists that records in some RMS - * structures end with a newline (carriage return) character, and - * if they don't it adds one. - * With other RMS structures it works perfect without this fix. - */ - if (buf->b_fab_rfm == FAB$C_VFC - || ((buf->b_fab_rat & (FAB$M_FTN | FAB$M_CR)) != 0)) - { - int b2write; - - buf->b_fab_mrs = (buf->b_fab_mrs == 0 - ? MIN(4096, bufsize) - : MIN(buf->b_fab_mrs, bufsize)); - - b2write = len; - while (b2write > 0) - { - write_info.bw_len = MIN(b2write, buf->b_fab_mrs); - if (buf_write_bytes(&write_info) == FAIL) - { - end = 0; - break; - } - b2write -= MIN(b2write, buf->b_fab_mrs); - } - write_info.bw_len = bufsize; - nchars += len; - s = buffer; - len = 0; - } -#endif - } - if (len > 0 && end > 0) - { - write_info.bw_len = len; - if (buf_write_bytes(&write_info) == FAIL) - end = 0; /* write error */ - nchars += len; - } - - /* Stop when writing done or an error was encountered. */ - if (!checking_conversion || end == 0) - break; - - /* If no error happened until now, writing should be ok, so loop to - * really write the buffer. */ - } - - /* If we started writing, finish writing. Also when an error was - * encountered. */ - if (!checking_conversion) - { -#if defined(UNIX) && defined(HAVE_FSYNC) - /* - * On many journalling file systems there is a bug that causes both the - * original and the backup file to be lost when halting the system - * right after writing the file. That's because only the meta-data is - * journalled. Syncing the file slows down the system, but assures it - * has been written to disk and we don't lose it. - * For a device do try the fsync() but don't complain if it does not - * work (could be a pipe). - * If the 'fsync' option is FALSE, don't fsync(). Useful for laptops. - */ - if (p_fs && vim_fsync(fd) != 0 && !device) - { - errmsg = (char_u *)_(e_fsync); - end = 0; - } -#endif - -#if defined(HAVE_SELINUX) || defined(HAVE_SMACK) - /* Probably need to set the security context. */ - if (!backup_copy) - mch_copy_sec(backup, wfname); -#endif - -#ifdef UNIX - /* When creating a new file, set its owner/group to that of the - * original file. Get the new device and inode number. */ - if (backup != NULL && !backup_copy) - { -# ifdef HAVE_FCHOWN - stat_T st; - - /* Don't change the owner when it's already OK, some systems remove - * permission or ACL stuff. */ - if (mch_stat((char *)wfname, &st) < 0 - || st.st_uid != st_old.st_uid - || st.st_gid != st_old.st_gid) - { - /* changing owner might not be possible */ - vim_ignored = fchown(fd, st_old.st_uid, -1); - /* if changing group fails clear the group permissions */ - if (fchown(fd, -1, st_old.st_gid) == -1 && perm > 0) - perm &= ~070; - } -# endif - buf_setino(buf); - } - else if (!buf->b_dev_valid) - /* Set the inode when creating a new file. */ - buf_setino(buf); -#endif - -#ifdef UNIX - if (made_writable) - perm &= ~0200; /* reset 'w' bit for security reasons */ -#endif -#ifdef HAVE_FCHMOD - /* set permission of new file same as old file */ - if (perm >= 0) - (void)mch_fsetperm(fd, perm); -#endif - if (close(fd) != 0) - { - errmsg = (char_u *)_("E512: Close failed"); - end = 0; - } - -#ifndef HAVE_FCHMOD - /* set permission of new file same as old file */ - if (perm >= 0) - (void)mch_setperm(wfname, perm); -#endif -#ifdef HAVE_ACL - /* - * Probably need to set the ACL before changing the user (can't set the - * ACL on a file the user doesn't own). - * On Solaris, with ZFS and the aclmode property set to "discard" (the - * default), chmod() discards all part of a file's ACL that don't - * represent the mode of the file. It's non-trivial for us to discover - * whether we're in that situation, so we simply always re-set the ACL. - */ -# ifndef HAVE_SOLARIS_ZFS_ACL - if (!backup_copy) -# endif - mch_set_acl(wfname, acl); -#endif -#ifdef FEAT_CRYPT - if (buf->b_cryptstate != NULL) - { - crypt_free_state(buf->b_cryptstate); - buf->b_cryptstate = NULL; - } -#endif - -#if defined(FEAT_EVAL) - if (wfname != fname) - { - /* - * The file was written to a temp file, now it needs to be - * converted with 'charconvert' to (overwrite) the output file. - */ - if (end != 0) - { - if (eval_charconvert(enc_utf8 ? (char_u *)"utf-8" : p_enc, - fenc, wfname, fname) == FAIL) - { - write_info.bw_conv_error = TRUE; - end = 0; - } - } - mch_remove(wfname); - vim_free(wfname); - } -#endif - } - - if (end == 0) - { - /* - * Error encountered. - */ - if (errmsg == NULL) - { - if (write_info.bw_conv_error) - { - if (write_info.bw_conv_error_lnum == 0) - errmsg = (char_u *)_("E513: write error, conversion failed (make 'fenc' empty to override)"); - else - { - errmsg_allocated = TRUE; - errmsg = alloc(300); - vim_snprintf((char *)errmsg, 300, _("E513: write error, conversion failed in line %ld (make 'fenc' empty to override)"), - (long)write_info.bw_conv_error_lnum); - } - } - else if (got_int) - errmsg = (char_u *)_(e_interr); - else - errmsg = (char_u *)_("E514: write error (file system full?)"); - } - - /* - * If we have a backup file, try to put it in place of the new file, - * because the new file is probably corrupt. This avoids losing the - * original file when trying to make a backup when writing the file a - * second time. - * When "backup_copy" is set we need to copy the backup over the new - * file. Otherwise rename the backup file. - * If this is OK, don't give the extra warning message. - */ - if (backup != NULL) - { - if (backup_copy) - { - /* This may take a while, if we were interrupted let the user - * know we got the message. */ - if (got_int) - { - msg(_(e_interr)); - out_flush(); - } - if ((fd = mch_open((char *)backup, O_RDONLY | O_EXTRA, 0)) >= 0) - { - if ((write_info.bw_fd = mch_open((char *)fname, - O_WRONLY | O_CREAT | O_TRUNC | O_EXTRA, - perm & 0777)) >= 0) - { - /* copy the file. */ - write_info.bw_buf = smallbuf; -#ifdef HAS_BW_FLAGS - write_info.bw_flags = FIO_NOCONVERT; -#endif - while ((write_info.bw_len = read_eintr(fd, smallbuf, - SMBUFSIZE)) > 0) - if (buf_write_bytes(&write_info) == FAIL) - break; - - if (close(write_info.bw_fd) >= 0 - && write_info.bw_len == 0) - end = 1; /* success */ - } - close(fd); /* ignore errors for closing read file */ - } - } - else - { - if (vim_rename(backup, fname) == 0) - end = 1; - } - } - goto fail; - } - - lnum -= start; /* compute number of written lines */ - --no_wait_return; /* may wait for return now */ - -#if !(defined(UNIX) || defined(VMS)) - fname = sfname; /* use shortname now, for the messages */ -#endif - if (!filtering) - { - msg_add_fname(buf, fname); /* put fname in IObuff with quotes */ - c = FALSE; - if (write_info.bw_conv_error) - { - STRCAT(IObuff, _(" CONVERSION ERROR")); - c = TRUE; - if (write_info.bw_conv_error_lnum != 0) - vim_snprintf_add((char *)IObuff, IOSIZE, _(" in line %ld;"), - (long)write_info.bw_conv_error_lnum); - } - else if (notconverted) - { - STRCAT(IObuff, _("[NOT converted]")); - c = TRUE; - } - else if (converted) - { - STRCAT(IObuff, _("[converted]")); - c = TRUE; - } - if (device) - { - STRCAT(IObuff, _("[Device]")); - c = TRUE; - } - else if (newfile) - { - STRCAT(IObuff, shortmess(SHM_NEW) ? _("[New]") : _("[New File]")); - c = TRUE; - } - if (no_eol) - { - msg_add_eol(); - c = TRUE; - } - /* may add [unix/dos/mac] */ - if (msg_add_fileformat(fileformat)) - c = TRUE; -#ifdef FEAT_CRYPT - if (wb_flags & FIO_ENCRYPTED) - { - crypt_append_msg(buf); - c = TRUE; - } -#endif - msg_add_lines(c, (long)lnum, nchars); /* add line/char count */ - if (!shortmess(SHM_WRITE)) - { - if (append) - STRCAT(IObuff, shortmess(SHM_WRI) ? _(" [a]") : _(" appended")); - else - STRCAT(IObuff, shortmess(SHM_WRI) ? _(" [w]") : _(" written")); - } - - set_keep_msg((char_u *)msg_trunc_attr((char *)IObuff, FALSE, 0), 0); - } - - /* When written everything correctly: reset 'modified'. Unless not - * writing to the original file and '+' is not in 'cpoptions'. */ - if (reset_changed && whole && !append - && !write_info.bw_conv_error - && (overwriting || vim_strchr(p_cpo, CPO_PLUS) != NULL)) - { - unchanged(buf, TRUE, FALSE); - /* b:changedtick is may be incremented in unchanged() but that - * should not trigger a TextChanged event. */ - if (buf->b_last_changedtick + 1 == CHANGEDTICK(buf)) - buf->b_last_changedtick = CHANGEDTICK(buf); - u_unchanged(buf); - u_update_save_nr(buf); - } - - /* - * If written to the current file, update the timestamp of the swap file - * and reset the BF_WRITE_MASK flags. Also sets buf->b_mtime. - */ - if (overwriting) - { - ml_timestamp(buf); - if (append) - buf->b_flags &= ~BF_NEW; - else - buf->b_flags &= ~BF_WRITE_MASK; - } - - /* - * If we kept a backup until now, and we are in patch mode, then we make - * the backup file our 'original' file. - */ - if (*p_pm && dobackup) - { - char *org = (char *)buf_modname((buf->b_p_sn || buf->b_shortname), - fname, p_pm, FALSE); - - if (backup != NULL) - { - stat_T st; - - /* - * If the original file does not exist yet - * the current backup file becomes the original file - */ - if (org == NULL) - emsg(_("E205: Patchmode: can't save original file")); - else if (mch_stat(org, &st) < 0) - { - vim_rename(backup, (char_u *)org); - VIM_CLEAR(backup); /* don't delete the file */ -#ifdef UNIX - set_file_time((char_u *)org, st_old.st_atime, st_old.st_mtime); -#endif - } - } - /* - * If there is no backup file, remember that a (new) file was - * created. - */ - else - { - int empty_fd; - - if (org == NULL - || (empty_fd = mch_open(org, - O_CREAT | O_EXTRA | O_EXCL | O_NOFOLLOW, - perm < 0 ? 0666 : (perm & 0777))) < 0) - emsg(_("E206: patchmode: can't touch empty original file")); - else - close(empty_fd); - } - if (org != NULL) - { - mch_setperm((char_u *)org, mch_getperm(fname) & 0777); - vim_free(org); - } - } - - // Remove the backup unless 'backup' option is set or there was a - // conversion error. - if (!p_bk && backup != NULL && !write_info.bw_conv_error - && mch_remove(backup) != 0) - emsg(_("E207: Can't delete backup file")); - - goto nofail; - - /* - * Finish up. We get here either after failure or success. - */ -fail: - --no_wait_return; /* may wait for return now */ -nofail: - - /* Done saving, we accept changed buffer warnings again */ - buf->b_saving = FALSE; - - vim_free(backup); - if (buffer != smallbuf) - vim_free(buffer); - vim_free(fenc_tofree); - vim_free(write_info.bw_conv_buf); -#ifdef USE_ICONV - if (write_info.bw_iconv_fd != (iconv_t)-1) - { - iconv_close(write_info.bw_iconv_fd); - write_info.bw_iconv_fd = (iconv_t)-1; - } -#endif -#ifdef HAVE_ACL - mch_free_acl(acl); -#endif - - if (errmsg != NULL) - { - int numlen = errnum != NULL ? (int)STRLEN(errnum) : 0; - - attr = HL_ATTR(HLF_E); /* set highlight for error messages */ - msg_add_fname(buf, -#ifndef UNIX - sfname -#else - fname -#endif - ); /* put file name in IObuff with quotes */ - if (STRLEN(IObuff) + STRLEN(errmsg) + numlen >= IOSIZE) - IObuff[IOSIZE - STRLEN(errmsg) - numlen - 1] = NUL; - /* If the error message has the form "is ...", put the error number in - * front of the file name. */ - if (errnum != NULL) - { - STRMOVE(IObuff + numlen, IObuff); - mch_memmove(IObuff, errnum, (size_t)numlen); - } - STRCAT(IObuff, errmsg); - emsg((char *)IObuff); - if (errmsg_allocated) - vim_free(errmsg); - - retval = FAIL; - if (end == 0) - { - msg_puts_attr(_("\nWARNING: Original file may be lost or damaged\n"), - attr | MSG_HIST); - msg_puts_attr(_("don't quit the editor until the file is successfully written!"), - attr | MSG_HIST); - - /* Update the timestamp to avoid an "overwrite changed file" - * prompt when writing again. */ - if (mch_stat((char *)fname, &st_old) >= 0) - { - buf_store_time(buf, &st_old, fname); - buf->b_mtime_read = buf->b_mtime; - } - } - } - msg_scroll = msg_save; - -#ifdef FEAT_PERSISTENT_UNDO - /* - * When writing the whole file and 'undofile' is set, also write the undo - * file. - */ - if (retval == OK && write_undo_file) - { - char_u hash[UNDO_HASH_SIZE]; - - sha256_finish(&sha_ctx, hash); - u_write_undo(NULL, FALSE, buf, hash); - } -#endif - -#ifdef FEAT_EVAL - if (!should_abort(retval)) -#else - if (!got_int) -#endif - { - aco_save_T aco; - - curbuf->b_no_eol_lnum = 0; /* in case it was set by the previous read */ - - /* - * Apply POST autocommands. - * Careful: The autocommands may call buf_write() recursively! - */ - aucmd_prepbuf(&aco, buf); - - if (append) - apply_autocmds_exarg(EVENT_FILEAPPENDPOST, fname, fname, - FALSE, curbuf, eap); - else if (filtering) - apply_autocmds_exarg(EVENT_FILTERWRITEPOST, NULL, fname, - FALSE, curbuf, eap); - else if (reset_changed && whole) - apply_autocmds_exarg(EVENT_BUFWRITEPOST, fname, fname, - FALSE, curbuf, eap); - else - apply_autocmds_exarg(EVENT_FILEWRITEPOST, fname, fname, - FALSE, curbuf, eap); - - /* restore curwin/curbuf and a few other things */ - aucmd_restbuf(&aco); - -#ifdef FEAT_EVAL - if (aborting()) /* autocmds may abort script processing */ - retval = FALSE; -#endif - } - - got_int |= prev_got_int; - - return retval; -} - #if defined(HAVE_FSYNC) || defined(PROTO) /* * Call fsync() with Mac-specific exception. @@ -5121,7 +2919,7 @@ vim_fsync(int fd) * Set the name of the current buffer. Use when the buffer doesn't have a * name and a ":r" or ":w" command with a file name is used. */ - static int + int set_rw_fname(char_u *fname, char_u *sfname) { buf_T *buf = curbuf; @@ -5181,7 +2979,7 @@ msg_add_fname(buf_T *buf, char_u *fname) * Append message for text mode to IObuff. * Return TRUE if something appended. */ - static int + int msg_add_fileformat(int eol_type) { #ifndef USE_CRNL @@ -5237,37 +3035,13 @@ msg_add_lines( /* * Append message for missing line separator to IObuff. */ - static void + void msg_add_eol(void) { STRCAT(IObuff, shortmess(SHM_LAST) ? _("[noeol]") : _("[Incomplete last line]")); } -/* - * Check modification time of file, before writing to it. - * The size isn't checked, because using a tool like "gzip" takes care of - * using the same timestamp but can't set the size. - */ - static int -check_mtime(buf_T *buf, stat_T *st) -{ - if (buf->b_mtime_read != 0 - && time_differs((long)st->st_mtime, buf->b_mtime_read)) - { - msg_scroll = TRUE; /* don't overwrite messages here */ - msg_silent = 0; /* must give this prompt */ - /* don't use emsg() here, don't want to flush the buffers */ - msg_attr(_("WARNING: The file has been changed since reading it!!!"), - HL_ATTR(HLF_E)); - if (ask_yesno((char_u *)_("Do you really want to write to it"), - TRUE) == 'n') - return FAIL; - msg_scroll = FALSE; /* always overwrite the file message now */ - } - return OK; -} - - static int + int time_differs(long t1, long t2) { #if defined(__linux__) || defined(MSWIN) @@ -5281,496 +3055,10 @@ time_differs(long t1, long t2) } /* - * Call write() to write a number of bytes to the file. - * Handles encryption and 'encoding' conversion. - * - * Return FAIL for failure, OK otherwise. - */ - static int -buf_write_bytes(struct bw_info *ip) -{ - int wlen; - char_u *buf = ip->bw_buf; /* data to write */ - int len = ip->bw_len; /* length of data */ -#ifdef HAS_BW_FLAGS - int flags = ip->bw_flags; /* extra flags */ -#endif - - /* - * Skip conversion when writing the crypt magic number or the BOM. - */ - if (!(flags & FIO_NOCONVERT)) - { - char_u *p; - unsigned c; - int n; - - if (flags & FIO_UTF8) - { - /* - * Convert latin1 in the buffer to UTF-8 in the file. - */ - p = ip->bw_conv_buf; /* translate to buffer */ - for (wlen = 0; wlen < len; ++wlen) - p += utf_char2bytes(buf[wlen], p); - buf = ip->bw_conv_buf; - len = (int)(p - ip->bw_conv_buf); - } - else if (flags & (FIO_UCS4 | FIO_UTF16 | FIO_UCS2 | FIO_LATIN1)) - { - /* - * Convert UTF-8 bytes in the buffer to UCS-2, UCS-4, UTF-16 or - * Latin1 chars in the file. - */ - if (flags & FIO_LATIN1) - p = buf; /* translate in-place (can only get shorter) */ - else - p = ip->bw_conv_buf; /* translate to buffer */ - for (wlen = 0; wlen < len; wlen += n) - { - if (wlen == 0 && ip->bw_restlen != 0) - { - int l; - - /* Use remainder of previous call. Append the start of - * buf[] to get a full sequence. Might still be too - * short! */ - l = CONV_RESTLEN - ip->bw_restlen; - if (l > len) - l = len; - mch_memmove(ip->bw_rest + ip->bw_restlen, buf, (size_t)l); - n = utf_ptr2len_len(ip->bw_rest, ip->bw_restlen + l); - if (n > ip->bw_restlen + len) - { - /* We have an incomplete byte sequence at the end to - * be written. We can't convert it without the - * remaining bytes. Keep them for the next call. */ - if (ip->bw_restlen + len > CONV_RESTLEN) - return FAIL; - ip->bw_restlen += len; - break; - } - if (n > 1) - c = utf_ptr2char(ip->bw_rest); - else - c = ip->bw_rest[0]; - if (n >= ip->bw_restlen) - { - n -= ip->bw_restlen; - ip->bw_restlen = 0; - } - else - { - ip->bw_restlen -= n; - mch_memmove(ip->bw_rest, ip->bw_rest + n, - (size_t)ip->bw_restlen); - n = 0; - } - } - else - { - n = utf_ptr2len_len(buf + wlen, len - wlen); - if (n > len - wlen) - { - /* We have an incomplete byte sequence at the end to - * be written. We can't convert it without the - * remaining bytes. Keep them for the next call. */ - if (len - wlen > CONV_RESTLEN) - return FAIL; - ip->bw_restlen = len - wlen; - mch_memmove(ip->bw_rest, buf + wlen, - (size_t)ip->bw_restlen); - break; - } - if (n > 1) - c = utf_ptr2char(buf + wlen); - else - c = buf[wlen]; - } - - if (ucs2bytes(c, &p, flags) && !ip->bw_conv_error) - { - ip->bw_conv_error = TRUE; - ip->bw_conv_error_lnum = ip->bw_start_lnum; - } - if (c == NL) - ++ip->bw_start_lnum; - } - if (flags & FIO_LATIN1) - len = (int)(p - buf); - else - { - buf = ip->bw_conv_buf; - len = (int)(p - ip->bw_conv_buf); - } - } - -#ifdef MSWIN - else if (flags & FIO_CODEPAGE) - { - /* - * Convert UTF-8 or codepage to UCS-2 and then to MS-Windows - * codepage. - */ - char_u *from; - size_t fromlen; - char_u *to; - int u8c; - BOOL bad = FALSE; - int needed; - - if (ip->bw_restlen > 0) - { - /* Need to concatenate the remainder of the previous call and - * the bytes of the current call. Use the end of the - * conversion buffer for this. */ - fromlen = len + ip->bw_restlen; - from = ip->bw_conv_buf + ip->bw_conv_buflen - fromlen; - mch_memmove(from, ip->bw_rest, (size_t)ip->bw_restlen); - mch_memmove(from + ip->bw_restlen, buf, (size_t)len); - } - else - { - from = buf; - fromlen = len; - } - - to = ip->bw_conv_buf; - if (enc_utf8) - { - /* Convert from UTF-8 to UCS-2, to the start of the buffer. - * The buffer has been allocated to be big enough. */ - while (fromlen > 0) - { - n = (int)utf_ptr2len_len(from, (int)fromlen); - if (n > (int)fromlen) /* incomplete byte sequence */ - break; - u8c = utf_ptr2char(from); - *to++ = (u8c & 0xff); - *to++ = (u8c >> 8); - fromlen -= n; - from += n; - } - - /* Copy remainder to ip->bw_rest[] to be used for the next - * call. */ - if (fromlen > CONV_RESTLEN) - { - /* weird overlong sequence */ - ip->bw_conv_error = TRUE; - return FAIL; - } - mch_memmove(ip->bw_rest, from, fromlen); - ip->bw_restlen = (int)fromlen; - } - else - { - /* Convert from enc_codepage to UCS-2, to the start of the - * buffer. The buffer has been allocated to be big enough. */ - ip->bw_restlen = 0; - needed = MultiByteToWideChar(enc_codepage, - MB_ERR_INVALID_CHARS, (LPCSTR)from, (int)fromlen, - NULL, 0); - if (needed == 0) - { - /* When conversion fails there may be a trailing byte. */ - needed = MultiByteToWideChar(enc_codepage, - MB_ERR_INVALID_CHARS, (LPCSTR)from, (int)fromlen - 1, - NULL, 0); - if (needed == 0) - { - /* Conversion doesn't work. */ - ip->bw_conv_error = TRUE; - return FAIL; - } - /* Save the trailing byte for the next call. */ - ip->bw_rest[0] = from[fromlen - 1]; - ip->bw_restlen = 1; - } - needed = MultiByteToWideChar(enc_codepage, MB_ERR_INVALID_CHARS, - (LPCSTR)from, (int)(fromlen - ip->bw_restlen), - (LPWSTR)to, needed); - if (needed == 0) - { - /* Safety check: Conversion doesn't work. */ - ip->bw_conv_error = TRUE; - return FAIL; - } - to += needed * 2; - } - - fromlen = to - ip->bw_conv_buf; - buf = to; -# ifdef CP_UTF8 /* VC 4.1 doesn't define CP_UTF8 */ - if (FIO_GET_CP(flags) == CP_UTF8) - { - /* Convert from UCS-2 to UTF-8, using the remainder of the - * conversion buffer. Fails when out of space. */ - for (from = ip->bw_conv_buf; fromlen > 1; fromlen -= 2) - { - u8c = *from++; - u8c += (*from++ << 8); - to += utf_char2bytes(u8c, to); - if (to + 6 >= ip->bw_conv_buf + ip->bw_conv_buflen) - { - ip->bw_conv_error = TRUE; - return FAIL; - } - } - len = (int)(to - buf); - } - else -# endif - { - /* Convert from UCS-2 to the codepage, using the remainder of - * the conversion buffer. If the conversion uses the default - * character "0", the data doesn't fit in this encoding, so - * fail. */ - len = WideCharToMultiByte(FIO_GET_CP(flags), 0, - (LPCWSTR)ip->bw_conv_buf, (int)fromlen / sizeof(WCHAR), - (LPSTR)to, (int)(ip->bw_conv_buflen - fromlen), 0, - &bad); - if (bad) - { - ip->bw_conv_error = TRUE; - return FAIL; - } - } - } -#endif - -#ifdef MACOS_CONVERT - else if (flags & FIO_MACROMAN) - { - /* - * Convert UTF-8 or latin1 to Apple MacRoman. - */ - char_u *from; - size_t fromlen; - - if (ip->bw_restlen > 0) - { - /* Need to concatenate the remainder of the previous call and - * the bytes of the current call. Use the end of the - * conversion buffer for this. */ - fromlen = len + ip->bw_restlen; - from = ip->bw_conv_buf + ip->bw_conv_buflen - fromlen; - mch_memmove(from, ip->bw_rest, (size_t)ip->bw_restlen); - mch_memmove(from + ip->bw_restlen, buf, (size_t)len); - } - else - { - from = buf; - fromlen = len; - } - - if (enc2macroman(from, fromlen, - ip->bw_conv_buf, &len, ip->bw_conv_buflen, - ip->bw_rest, &ip->bw_restlen) == FAIL) - { - ip->bw_conv_error = TRUE; - return FAIL; - } - buf = ip->bw_conv_buf; - } -#endif - -#ifdef USE_ICONV - if (ip->bw_iconv_fd != (iconv_t)-1) - { - const char *from; - size_t fromlen; - char *to; - size_t tolen; - - /* Convert with iconv(). */ - if (ip->bw_restlen > 0) - { - char *fp; - - /* Need to concatenate the remainder of the previous call and - * the bytes of the current call. Use the end of the - * conversion buffer for this. */ - fromlen = len + ip->bw_restlen; - fp = (char *)ip->bw_conv_buf + ip->bw_conv_buflen - fromlen; - mch_memmove(fp, ip->bw_rest, (size_t)ip->bw_restlen); - mch_memmove(fp + ip->bw_restlen, buf, (size_t)len); - from = fp; - tolen = ip->bw_conv_buflen - fromlen; - } - else - { - from = (const char *)buf; - fromlen = len; - tolen = ip->bw_conv_buflen; - } - to = (char *)ip->bw_conv_buf; - - if (ip->bw_first) - { - size_t save_len = tolen; - - /* output the initial shift state sequence */ - (void)iconv(ip->bw_iconv_fd, NULL, NULL, &to, &tolen); - - /* There is a bug in iconv() on Linux (which appears to be - * wide-spread) which sets "to" to NULL and messes up "tolen". - */ - if (to == NULL) - { - to = (char *)ip->bw_conv_buf; - tolen = save_len; - } - ip->bw_first = FALSE; - } - - /* - * If iconv() has an error or there is not enough room, fail. - */ - if ((iconv(ip->bw_iconv_fd, (void *)&from, &fromlen, &to, &tolen) - == (size_t)-1 && ICONV_ERRNO != ICONV_EINVAL) - || fromlen > CONV_RESTLEN) - { - ip->bw_conv_error = TRUE; - return FAIL; - } - - /* copy remainder to ip->bw_rest[] to be used for the next call. */ - if (fromlen > 0) - mch_memmove(ip->bw_rest, (void *)from, fromlen); - ip->bw_restlen = (int)fromlen; - - buf = ip->bw_conv_buf; - len = (int)((char_u *)to - ip->bw_conv_buf); - } -#endif - } - - if (ip->bw_fd < 0) - /* Only checking conversion, which is OK if we get here. */ - return OK; - -#ifdef FEAT_CRYPT - if (flags & FIO_ENCRYPTED) - { - /* Encrypt the data. Do it in-place if possible, otherwise use an - * allocated buffer. */ -# ifdef CRYPT_NOT_INPLACE - if (crypt_works_inplace(ip->bw_buffer->b_cryptstate)) - { -# endif - crypt_encode_inplace(ip->bw_buffer->b_cryptstate, buf, len); -# ifdef CRYPT_NOT_INPLACE - } - else - { - char_u *outbuf; - - len = crypt_encode_alloc(curbuf->b_cryptstate, buf, len, &outbuf); - if (len == 0) - return OK; /* Crypt layer is buffering, will flush later. */ - wlen = write_eintr(ip->bw_fd, outbuf, len); - vim_free(outbuf); - return (wlen < len) ? FAIL : OK; - } -# endif - } -#endif - - wlen = write_eintr(ip->bw_fd, buf, len); - return (wlen < len) ? FAIL : OK; -} - -/* - * Convert a Unicode character to bytes. - * Return TRUE for an error, FALSE when it's OK. - */ - static int -ucs2bytes( - unsigned c, /* in: character */ - char_u **pp, /* in/out: pointer to result */ - int flags) /* FIO_ flags */ -{ - char_u *p = *pp; - int error = FALSE; - int cc; - - - if (flags & FIO_UCS4) - { - if (flags & FIO_ENDIAN_L) - { - *p++ = c; - *p++ = (c >> 8); - *p++ = (c >> 16); - *p++ = (c >> 24); - } - else - { - *p++ = (c >> 24); - *p++ = (c >> 16); - *p++ = (c >> 8); - *p++ = c; - } - } - else if (flags & (FIO_UCS2 | FIO_UTF16)) - { - if (c >= 0x10000) - { - if (flags & FIO_UTF16) - { - /* Make two words, ten bits of the character in each. First - * word is 0xd800 - 0xdbff, second one 0xdc00 - 0xdfff */ - c -= 0x10000; - if (c >= 0x100000) - error = TRUE; - cc = ((c >> 10) & 0x3ff) + 0xd800; - if (flags & FIO_ENDIAN_L) - { - *p++ = cc; - *p++ = ((unsigned)cc >> 8); - } - else - { - *p++ = ((unsigned)cc >> 8); - *p++ = cc; - } - c = (c & 0x3ff) + 0xdc00; - } - else - error = TRUE; - } - if (flags & FIO_ENDIAN_L) - { - *p++ = c; - *p++ = (c >> 8); - } - else - { - *p++ = (c >> 8); - *p++ = c; - } - } - else /* Latin1 */ - { - if (c >= 0x100) - { - error = TRUE; - *p++ = 0xBF; - } - else - *p++ = c; - } - - *pp = p; - return error; -} - -/* * Return TRUE if file encoding "fenc" requires conversion from or to * 'encoding'. */ - static int + int need_conversion(char_u *fenc) { int same_encoding; @@ -5807,7 +3095,7 @@ need_conversion(char_u *fenc) * internal conversion. * if "ptr" is an empty string, use 'encoding'. */ - static int + int get_fio_flags(char_u *ptr) { int prop; @@ -5844,13 +3132,13 @@ get_fio_flags(char_u *ptr) return 0; } -#ifdef MSWIN +#if defined(MSWIN) || defined(PROTO) /* * Check "ptr" for a MS-Windows codepage name and return the FIO_ flags needed * for the conversion MS-Windows can do for us. Also accept "utf-8". * Used for conversion between 'encoding' and 'fileencoding'. */ - static int + int get_win_fio_flags(char_u *ptr) { int cp; @@ -5873,12 +3161,12 @@ get_win_fio_flags(char_u *ptr) } #endif -#ifdef MACOS_CONVERT +#if defined(MACOS_CONVERT) || defined(PROTO) /* * Check "ptr" for a Carbon supported encoding and return the FIO_ flags * needed for the internal conversion to/from utf-8 or latin1. */ - static int + int get_mac_fio_flags(char_u *ptr) { if ((enc_utf8 || STRCMP(p_enc, "latin1") == 0) @@ -5945,34 +3233,6 @@ check_for_bom( } /* - * Generate a BOM in "buf[4]" for encoding "name". - * Return the length of the BOM (zero when no BOM). - */ - static int -make_bom(char_u *buf, char_u *name) -{ - int flags; - char_u *p; - - flags = get_fio_flags(name); - - /* Can't put a BOM in a non-Unicode file. */ - if (flags == FIO_LATIN1 || flags == 0) - return 0; - - if (flags == FIO_UTF8) /* UTF-8 */ - { - buf[0] = 0xef; - buf[1] = 0xbb; - buf[2] = 0xbf; - return 3; - } - p = buf; - (void)ucs2bytes(0xfeff, &p, flags); - return (int)(p - buf); -} - -/* * Try to find a shortname by comparing the fullname with the current * directory. * Returns "full_path" or pointer into "full_path" if shortened. @@ -6517,7 +3777,7 @@ vim_rename(char_u *from, char_u *to) return -1; } - buffer = alloc(BUFSIZE); + buffer = alloc(WRITEBUFSIZE); if (buffer == NULL) { close(fd_out); @@ -6528,7 +3788,7 @@ vim_rename(char_u *from, char_u *to) return -1; } - while ((n = read_eintr(fd_in, buffer, BUFSIZE)) > 0) + while ((n = read_eintr(fd_in, buffer, WRITEBUFSIZE)) > 0) if (write_eintr(fd_out, buffer, n) != n) { errmsg = _("E208: Error writing to \"%s\""); diff --git a/src/option.c b/src/option.c --- a/src/option.c +++ b/src/option.c @@ -5530,7 +5530,7 @@ win_copy_options(win_T *wp_from, win_T * * After copying window options: update variables depending on options. */ void -after_copy_winopt(win_T *wp) +after_copy_winopt(win_T *wp UNUSED) { #ifdef FEAT_LINEBREAK briopt_check(wp); @@ -5852,6 +5852,8 @@ buf_copy_options(buf_T *buf, int flags) #endif buf->b_p_fo = vim_strsave(p_fo); buf->b_p_flp = vim_strsave(p_flp); + // NOTE: Valgrind may report a bogus memory leak for 'nrformats' + // when it is set to 8 bytes in defaults.vim. buf->b_p_nf = vim_strsave(p_nf); buf->b_p_mps = vim_strsave(p_mps); #ifdef FEAT_SMARTINDENT diff --git a/src/proto.h b/src/proto.h --- a/src/proto.h +++ b/src/proto.h @@ -64,6 +64,7 @@ extern int _stricoll(char *a, char *b); # include "arglist.pro" # include "autocmd.pro" # include "buffer.pro" +# include "bufwrite.pro" # include "change.pro" # include "charset.pro" # include "cmdexpand.pro" diff --git a/src/proto/bufwrite.pro b/src/proto/bufwrite.pro new file mode 100644 --- /dev/null +++ b/src/proto/bufwrite.pro @@ -0,0 +1,4 @@ +/* bufwrite.c */ +int buf_write(buf_T *buf, char_u *fname, char_u *sfname, linenr_T start, linenr_T end, exarg_T *eap, int append, int forceit, int reset_changed, int filtering); +/* vim: set ft=c : */ + diff --git a/src/proto/fileio.pro b/src/proto/fileio.pro --- a/src/proto/fileio.pro +++ b/src/proto/fileio.pro @@ -1,14 +1,22 @@ /* fileio.c */ +void filemess(buf_T *buf, char_u *name, char_u *s, int attr); int readfile(char_u *fname, char_u *sfname, linenr_T from, linenr_T lines_to_skip, linenr_T lines_to_read, exarg_T *eap, int flags); int is_dev_fd_file(char_u *fname); int prep_exarg(exarg_T *eap, buf_T *buf); void set_file_options(int set_options, exarg_T *eap); void set_forced_fenc(exarg_T *eap); int check_file_readonly(char_u *fname, int perm); -int buf_write(buf_T *buf, char_u *fname, char_u *sfname, linenr_T start, linenr_T end, exarg_T *eap, int append, int forceit, int reset_changed, int filtering); int vim_fsync(int fd); +int set_rw_fname(char_u *fname, char_u *sfname); void msg_add_fname(buf_T *buf, char_u *fname); +int msg_add_fileformat(int eol_type); void msg_add_lines(int insert_space, long lnum, off_T nchars); +void msg_add_eol(void); +int time_differs(long t1, long t2); +int need_conversion(char_u *fenc); +int get_fio_flags(char_u *ptr); +int get_win_fio_flags(char_u *ptr); +int get_mac_fio_flags(char_u *ptr); char_u *shorten_fname1(char_u *full_path); char_u *shorten_fname(char_u *full_path, char_u *dir_name); void shorten_buf_fname(buf_T *buf, char_u *dirname, int force); diff --git a/src/structs.h b/src/structs.h --- a/src/structs.h +++ b/src/structs.h @@ -3882,3 +3882,32 @@ typedef struct spat int no_scs; // no smartcase for this pattern soffset_T off; } spat_T; + +#define WRITEBUFSIZE 8192 // size of normal write buffer + +#define FIO_LATIN1 0x01 // convert Latin1 +#define FIO_UTF8 0x02 // convert UTF-8 +#define FIO_UCS2 0x04 // convert UCS-2 +#define FIO_UCS4 0x08 // convert UCS-4 +#define FIO_UTF16 0x10 // convert UTF-16 +#ifdef MSWIN +# define FIO_CODEPAGE 0x20 // convert MS-Windows codepage +# define FIO_PUT_CP(x) (((x) & 0xffff) << 16) // put codepage in top word +# define FIO_GET_CP(x) (((x)>>16) & 0xffff) // get codepage from top word +#endif +#ifdef MACOS_CONVERT +# define FIO_MACROMAN 0x20 // convert MacRoman +#endif +#define FIO_ENDIAN_L 0x80 // little endian +#define FIO_ENCRYPTED 0x1000 // encrypt written bytes +#define FIO_NOCONVERT 0x2000 // skip encoding conversion +#define FIO_UCSBOM 0x4000 // check for BOM at start of file +#define FIO_ALL -1 // allow all formats + +// When converting, a read() or write() may leave some bytes to be converted +// for the next call. The value is guessed... +#define CONV_RESTLEN 30 + +// We have to guess how much a sequence of bytes may expand when converting +// with iconv() to be able to allocate a buffer. +#define ICONV_MULT 8 diff --git a/src/version.c b/src/version.c --- a/src/version.c +++ b/src/version.c @@ -758,6 +758,8 @@ static char *(features[]) = static int included_patches[] = { /* Add new patch number below this line */ /**/ + 2094, +/**/ 2093, /**/ 2092,