/* 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 <utime.h> // 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