neovim

bufwrite.c (60699B)

---

// bufwrite.c: functions for writing a buffer

#include <fcntl.h>
#include <iconv.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <uv.h>

#include "auto/config.h"
#include "nvim/ascii_defs.h"
#include "nvim/autocmd.h"
#include "nvim/autocmd_defs.h"
#include "nvim/buffer.h"
#include "nvim/buffer_defs.h"
#include "nvim/bufwrite.h"
#include "nvim/change.h"
#include "nvim/drawscreen.h"
#include "nvim/errors.h"
#include "nvim/eval/typval_defs.h"
#include "nvim/eval/vars.h"
#include "nvim/ex_cmds.h"
#include "nvim/ex_cmds_defs.h"
#include "nvim/ex_eval.h"
#include "nvim/fileio.h"
#include "nvim/gettext_defs.h"
#include "nvim/globals.h"
#include "nvim/highlight_defs.h"
#include "nvim/iconv_defs.h"
#include "nvim/input.h"
#include "nvim/macros_defs.h"
#include "nvim/mbyte.h"
#include "nvim/memline.h"
#include "nvim/memline_defs.h"
#include "nvim/memory.h"
#include "nvim/message.h"
#include "nvim/option.h"
#include "nvim/option_vars.h"
#include "nvim/os/fs.h"
#include "nvim/os/fs_defs.h"
#include "nvim/os/input.h"
#include "nvim/os/os_defs.h"
#include "nvim/path.h"
#include "nvim/pos_defs.h"
#include "nvim/sha256.h"
#include "nvim/strings.h"
#include "nvim/types_defs.h"
#include "nvim/ui.h"
#include "nvim/undo.h"
#include "nvim/undo_defs.h"
#include "nvim/vim_defs.h"

static const char *err_readonly = "is read-only (cannot override: \"W\" in 'cpoptions')";
static const char e_patchmode_cant_touch_empty_original_file[]
 = N_("E206: Patchmode: can't touch empty original file");
static const char e_write_error_conversion_failed_make_fenc_empty_to_override[]
 = N_("E513: Write error, conversion failed (make 'fenc' empty to override)");
static const char e_write_error_conversion_failed_in_line_nr_make_fenc_empty_to_override[]
 = N_("E513: Write error, conversion failed in line %" PRIdLINENR
      " (make 'fenc' empty to override)");
static const char e_write_error_file_system_full[]
 = N_("E514: Write error (file system full?)");
static const char e_no_matching_autocommands_for_buftype_str_buffer[]
 = N_("E676: No matching autocommands for buftype=%s buffer");

typedef struct {
 const char *num;
 char *msg;
 int arg;
 bool alloc;
} Error_T;

#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 *bw_buf;                   // buffer with data to be written
 int bw_len;                     // length of data
 int bw_flags;                   // FIO_ flags
 int bw_first;                   // first write call
 char *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
 iconv_t bw_iconv_fd;            // descriptor for iconv() or -1
};

#include "bufwrite.c.generated.h"

/// Convert a Unicode character to bytes.
///
/// @param c character to convert
/// @param[in,out] pp pointer to store the result at
/// @param flags FIO_ flags that specify which encoding to use
///
/// @return true for an error, false when it's OK.
static bool ucs2bytes(unsigned c, char **pp, int flags)
 FUNC_ATTR_NONNULL_ALL
{
 uint8_t *p = (uint8_t *)(*pp);
 bool error = false;

 if (flags & FIO_UCS4) {
   if (flags & FIO_ENDIAN_L) {
     *p++ = (uint8_t)c;
     *p++ = (uint8_t)(c >> 8);
     *p++ = (uint8_t)(c >> 16);
     *p++ = (uint8_t)(c >> 24);
   } else {
     *p++ = (uint8_t)(c >> 24);
     *p++ = (uint8_t)(c >> 16);
     *p++ = (uint8_t)(c >> 8);
     *p++ = (uint8_t)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;
       }
       int cc = (int)(((c >> 10) & 0x3ff) + 0xd800);
       if (flags & FIO_ENDIAN_L) {
         *p++ = (uint8_t)cc;
         *p++ = (uint8_t)(cc >> 8);
       } else {
         *p++ = (uint8_t)(cc >> 8);
         *p++ = (uint8_t)cc;
       }
       c = (c & 0x3ff) + 0xdc00;
     } else {
       error = true;
     }
   }
   if (flags & FIO_ENDIAN_L) {
     *p++ = (uint8_t)c;
     *p++ = (uint8_t)(c >> 8);
   } else {
     *p++ = (uint8_t)(c >> 8);
     *p++ = (uint8_t)c;
   }
 } else {  // Latin1
   if (c >= 0x100) {
     error = true;
     *p++ = 0xBF;
   } else {
     *p++ = (uint8_t)c;
   }
 }

 *pp = (char *)p;
 return error;
}

/// Converts a buffer encoding based on values in ip using iconv.
///
/// See buf_write_convert for parameters and return value details.
static int buf_write_convert_with_iconv(struct bw_info *ip, char **bufp, int *lenp)
{
 int len = *lenp;

 // Convert with iconv().
 const char *from = *bufp;
 size_t fromlen = (size_t)len;
 size_t tolen = ip->bw_conv_buflen;
 char *to = ip->bw_conv_buf;

 if (ip->bw_first) {
   size_t save_len = tolen;

   // output the initial shift state sequence
   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 = ip->bw_conv_buf;
     tolen = save_len;
   }
   ip->bw_first = false;
 }

 // If iconv() has an error, fail.
 if (iconv(ip->bw_iconv_fd, (void *)&from, &fromlen, &to, &tolen)
     == (size_t)-1 && ICONV_ERRNO != ICONV_EINVAL) {
   ip->bw_conv_error = true;
   return -1;
 }

 *bufp = ip->bw_conv_buf;
 *lenp = (int)(to - ip->bw_conv_buf);

 return len - (int)fromlen;
}

/// Converts a buffer encoding based on values in ip.
///
/// @param ip buf_write_bytes context
/// @param[in,out] bufp Pointer to the input buffer. On return, pointer to the output buffer.
/// @param[in,out] lenp Pointer to the input buffer length. On return the referenced value is set to
///                     the length of the output buffer.
///
/// @return The number of input buffer bytes consumed for the conversion, which may be less than the
///         initial input buffer size when the buffer ends with an incomplete character sequence.
static int buf_write_convert(struct bw_info *ip, char **bufp, int *lenp)
{
 int flags = ip->bw_flags;  // extra flags

 int wlen = *lenp;
 if (flags & (FIO_UCS4 | FIO_UTF16 | FIO_UCS2 | FIO_LATIN1)) {
   unsigned c;
   int n = 0;
   // Convert UTF-8 bytes in the buffer to UCS-2, UCS-4, UTF-16 or
   // Latin1 chars in the file.
   // translate in-place (can only get shorter) or to buffer
   char *p = flags & FIO_LATIN1 ? *bufp : ip->bw_conv_buf;
   for (wlen = 0; wlen < *lenp; wlen += n) {
     n = utf_ptr2len_len(*bufp + wlen, *lenp - wlen);
     if (n > *lenp - 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.
       break;
     }
     c = n > 1 ? (unsigned)utf_ptr2char(*bufp + wlen)
               : (uint8_t)(*bufp)[wlen];
     // Check that there is enough space
     if (!(flags & FIO_LATIN1)) {
       size_t need = (flags & FIO_UCS4) ? 4 : 2;
       if ((flags & FIO_UTF16) && c >= 0x10000) {
         need = 4;
       }

       if ((size_t)(p - ip->bw_conv_buf) + need > ip->bw_conv_buflen) {
         return FAIL;
       }
     }

     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) {
     *lenp = (int)(p - *bufp);
   } else {
     *bufp = ip->bw_conv_buf;
     *lenp = (int)(p - ip->bw_conv_buf);
   }
 }

 if (ip->bw_iconv_fd != (iconv_t)-1) {
   return buf_write_convert_with_iconv(ip, bufp, lenp);
 }

 return wlen;
}

/// Call write() to write a number of bytes to the file.
/// Handles 'encoding' conversion.
///
/// @return  FAIL for failure, OK otherwise.
static int buf_write_bytes(struct bw_info *ip)
{
 char *buf = ip->bw_buf;    // data to write
 int len = ip->bw_len;      // length of data
 int flags = ip->bw_flags;  // extra flags

 int converted = len;
 int remaining = 0;

 // Skip conversion when writing the BOM.
 if (!(flags & FIO_NOCONVERT)) {
   if ((converted = buf_write_convert(ip, &buf, &len)) < 0) {
     return FAIL;
   }

   remaining = ip->bw_len - converted;
 }

 ip->bw_len = remaining;

 // Skip writing while checking conversion
 if (ip->bw_fd >= 0) {
   int wlen = (int)write_eintr(ip->bw_fd, buf, (size_t)len);
   if (wlen < len) {
     return FAIL;
   }
 }

 if (remaining > 0) {
   memmove(ip->bw_buf, ip->bw_buf + converted, (size_t)remaining);
 }

 return 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, FileInfo *file_info)
{
 if (buf->b_mtime_read != 0
     && time_differs(file_info, buf->b_mtime_read, buf->b_mtime_read_ns)) {
   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(_("WARNING: The file has been changed since reading it!!!"), HLF_E);
   if (ask_yesno(_("Do you really want to write to it")) == '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 *buf_in, char *name)
{
 uint8_t *buf = (uint8_t *)buf_in;
 int 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;
 }
 char *p = (char *)buf;
 ucs2bytes(0xfeff, &p, flags);
 return (int)((uint8_t *)p - buf);
}

static int buf_write_do_autocmds(buf_T *buf, char **fnamep, char **sfnamep, char **ffnamep,
                                linenr_T start, linenr_T *endp, exarg_T *eap, bool append,
                                bool filtering, bool reset_changed, bool overwriting, bool whole,
                                const pos_T orig_start, const pos_T orig_end)
{
 linenr_T old_line_count = buf->b_ml.ml_line_count;
 int msg_save = msg_scroll;

 aco_save_T aco;
 bool did_cmd = false;
 bool nofile_err = false;
 bool empty_memline = buf->b_ml.ml_mfp == NULL;
 bufref_T bufref;

 char *sfname = *sfnamep;

 // Apply PRE autocommands.
 // Set curbuf to the buffer to be written.
 // Careful: The autocommands may call buf_write() recursively!
 bool buf_ffname = *ffnamep == buf->b_ffname;
 bool buf_sfname = sfname == buf->b_sfname;
 bool buf_fname_f = *fnamep == buf->b_ffname;
 bool buf_fname_s = *fnamep == buf->b_sfname;

 // Set curwin/curbuf to buf and save a few things.
 aucmd_prepbuf(&aco, buf);
 set_bufref(&bufref, buf);

 if (append) {
   did_cmd = apply_autocmds_exarg(EVENT_FILEAPPENDCMD, sfname, sfname, false, curbuf, eap);
   if (!did_cmd) {
     if (overwriting && bt_nofilename(curbuf)) {
       nofile_err = true;
     } else {
       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) {
   bool 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 {
     if (overwriting && bt_nofilename(curbuf)) {
       nofile_err = true;
     } else {
       apply_autocmds_exarg(EVENT_BUFWRITEPRE,
                            sfname, sfname, false, curbuf, eap);
     }
   }
 } else {
   did_cmd = apply_autocmds_exarg(EVENT_FILEWRITECMD, sfname, sfname, false, curbuf, eap);
   if (!did_cmd) {
     if (overwriting && bt_nofilename(curbuf)) {
       nofile_err = true;
     } else {
       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
     || aborting()) {
   if (buf != NULL && (cmdmod.cmod_flags & CMOD_LOCKMARKS)) {
     // restore the original '[ and '] positions
     buf->b_op_start = orig_start;
     buf->b_op_end = orig_end;
   }

   no_wait_return--;
   msg_scroll = msg_save;
   if (nofile_err) {
     semsg(_(e_no_matching_autocommands_for_buftype_str_buffer), curbuf->b_p_bt);
   }

   if (nofile_err || aborting()) {
     // 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;
   }
   if (!aborting()) {
     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
     *endp = buf->b_ml.ml_line_count;
   } else if (buf->b_ml.ml_line_count > old_line_count) {           // more lines
     *endp += buf->b_ml.ml_line_count - old_line_count;
   } else {                                                    // less lines
     *endp -= old_line_count - buf->b_ml.ml_line_count;
     if (*endp < 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) {
   *ffnamep = buf->b_ffname;
 }
 if (buf_sfname) {
   *sfnamep = buf->b_sfname;
 }
 if (buf_fname_f) {
   *fnamep = buf->b_ffname;
 }
 if (buf_fname_s) {
   *fnamep = buf->b_sfname;
 }
 return NOTDONE;
}

static void buf_write_do_post_autocmds(buf_T *buf, char *fname, exarg_T *eap, bool append,
                                      bool filtering, bool reset_changed, bool whole)
{
 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);
}

static inline Error_T set_err_num(const char *num, const char *msg)
{
 return (Error_T){ .num = num, .msg = (char *)msg, .arg = 0 };
}

static inline Error_T set_err(const char *msg)
{
 return (Error_T){ .num = NULL, .msg = (char *)msg, .arg = 0 };
}

static inline Error_T set_err_arg(const char *msg, int arg)
{
 return (Error_T){ .num = NULL, .msg = (char *)msg, .arg = arg };
}

static void emit_err(Error_T *e)
{
 if (e->num != NULL) {
   if (e->arg != 0) {
     semsg("%s: %s%s: %s", e->num, IObuff, e->msg, os_strerror(e->arg));
   } else {
     semsg("%s: %s%s", e->num, IObuff, e->msg);
   }
 } else if (e->arg != 0) {
   semsg(e->msg, os_strerror(e->arg));
 } else {
   emsg(e->msg);
 }
 if (e->alloc) {
   xfree(e->msg);
 }
}

#if defined(UNIX)

static int get_fileinfo_os(char *fname, FileInfo *file_info_old, bool overwriting, int *perm,
                          bool *device, bool *newfile, Error_T *err)
{
 *perm = -1;
 if (!os_fileinfo(fname, file_info_old)) {
   *newfile = true;
 } else {
   *perm = (int)file_info_old->stat.st_mode;
   if (!S_ISREG(file_info_old->stat.st_mode)) {             // not a file
     if (S_ISDIR(file_info_old->stat.st_mode)) {
       *err = set_err_num("E502", _("is a directory"));
       return FAIL;
     }
     if (os_nodetype(fname) != NODE_WRITABLE) {
       *err = set_err_num("E503", _("is not a file or writable device"));
       return 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;
   }
 }
 return OK;
}

#else

static int get_fileinfo_os(char *fname, FileInfo *file_info_old, bool overwriting, int *perm,
                          bool *device, bool *newfile, Error_T *err)
{
 // Check for a writable device name.
 char nodetype = fname == NULL ? NODE_OTHER : (char)os_nodetype(fname);
 if (nodetype == NODE_OTHER) {
   *err = set_err_num("E503", _("is not a file or writable device"));
   return FAIL;
 }
 if (nodetype == NODE_WRITABLE) {
   *device = true;
   *newfile = true;
   *perm = -1;
 } else {
   *perm = os_getperm(fname);
   if (*perm < 0) {
     *newfile = true;
   } else if (os_isdir(fname)) {
     *err = set_err_num("E502", _("is a directory"));
     return FAIL;
   }
   if (overwriting) {
     os_fileinfo(fname, file_info_old);
   }
 }
 return OK;
}

#endif

/// @param buf
/// @param fname          File name
/// @param overwriting
/// @param forceit
/// @param[out] file_info_old
/// @param[out] perm
/// @param[out] device
/// @param[out] newfile
/// @param[out] readonly
static int get_fileinfo(buf_T *buf, char *fname, bool overwriting, bool forceit,
                       FileInfo *file_info_old, int *perm, bool *device, bool *newfile,
                       bool *readonly, Error_T *err)
{
 if (get_fileinfo_os(fname, file_info_old, overwriting, perm, device, newfile, err) == FAIL) {
   return FAIL;
 }

 *readonly = false;  // overwritten file is read-only

 if (!*device && !*newfile) {
   // Check if the file is really writable (when renaming the file to
   // make a backup we won't discover it later).
   *readonly = !os_file_is_writable(fname);

   if (!forceit && *readonly) {
     if (vim_strchr(p_cpo, CPO_FWRITE) != NULL) {
       *err = set_err_num("E504", _(err_readonly));
     } else {
       *err = set_err_num("E505", _("is read-only (add ! to override)"));
     }
     return FAIL;
   }

   // If 'forceit' is false, check if the timestamp hasn't changed since reading the file.
   if (overwriting && !forceit) {
     int retval = check_mtime(buf, file_info_old);
     if (retval == FAIL) {
       return FAIL;
     }
   }
 }
 return OK;
}

/// @return The backup file name
char *buf_get_backup_name(char *fname, char **dirp, bool no_prepend_dot, char *backup_ext)
{
 char *backup = NULL;
 // Isolate one directory name, using an entry in 'bdir'.
 size_t dir_len = copy_option_part(dirp, IObuff, IOSIZE, ",");
 char *p = IObuff + dir_len;
 if (**dirp == NUL && !os_isdir(IObuff)) {
   int ret;
   char *failed_dir;
   if ((ret = os_mkdir_recurse(IObuff, 0755, &failed_dir, NULL)) != 0) {
     semsg(_("E303: Unable to create directory \"%s\" for backup file: %s"),
           failed_dir, os_strerror(ret));
     xfree(failed_dir);
   }
 }
 if (after_pathsep(IObuff, p) && p[-1] == p[-2]) {
   // path ends with '//', use full path
   if ((p = make_percent_swname(IObuff, p, fname))
       != NULL) {
     backup = modname(p, backup_ext, no_prepend_dot);
     xfree(p);
   }
 }
 if (backup == NULL) {
   char *rootname = get_file_in_dir(fname, IObuff);
   if (rootname != NULL) {
     backup = modname(rootname, backup_ext, no_prepend_dot);
     xfree(rootname);
   }
 }
 return backup;
}

static int buf_write_make_backup(char *fname, bool append, FileInfo *file_info_old, vim_acl_T acl,
                                int perm, unsigned bkc, bool file_readonly, bool forceit,
                                bool *backup_copyp, char **backupp, Error_T *err)
{
 FileInfo file_info;
 const bool no_prepend_dot = false;

 if ((bkc & kOptBkcFlagYes) || append) {       // "yes"
   *backup_copyp = true;
 } else if ((bkc & kOptBkcFlagAuto)) {          // "auto"
   // 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
   if (os_fileinfo_hardlinks(file_info_old) > 1
       || !os_fileinfo_link(fname, &file_info)
       || !os_fileinfo_id_equal(&file_info, file_info_old)) {
     *backup_copyp = true;
   } else {
     // 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).
     size_t dirlen = (size_t)(path_tail(fname) - fname);
     assert(dirlen < MAXPATHL);
     char tmp_fname[MAXPATHL];
     xmemcpyz(tmp_fname, fname, dirlen);
     for (int i = 4913;; i += 123) {
       snprintf(tmp_fname + dirlen, sizeof(tmp_fname) - dirlen, "%d", i);
       if (!os_fileinfo_link(tmp_fname, &file_info)) {
         break;
       }
     }
     int fd = os_open(tmp_fname,
                      O_CREAT|O_WRONLY|O_EXCL|O_NOFOLLOW, perm);
     if (fd < 0) {           // can't write in directory
       *backup_copyp = true;
     } else {
#ifdef UNIX
       os_fchown(fd, (uv_uid_t)file_info_old->stat.st_uid, (uv_gid_t)file_info_old->stat.st_gid);
       if (!os_fileinfo(tmp_fname, &file_info)
           || file_info.stat.st_uid != file_info_old->stat.st_uid
           || file_info.stat.st_gid != file_info_old->stat.st_gid
           || (int)file_info.stat.st_mode != perm) {
         *backup_copyp = true;
       }
#endif
       // Close the file before removing it, on MS-Windows we
       // can't delete an open file.
       close(fd);
       os_remove(tmp_fname);
     }
   }
 }

 // Break symlinks and/or hardlinks if we've been asked to.
 if ((bkc & kOptBkcFlagBreaksymlink) || (bkc & kOptBkcFlagBreakhardlink)) {
#ifdef UNIX
   bool file_info_link_ok = os_fileinfo_link(fname, &file_info);

   // Symlinks.
   if ((bkc & kOptBkcFlagBreaksymlink)
       && file_info_link_ok
       && !os_fileinfo_id_equal(&file_info, file_info_old)) {
     *backup_copyp = false;
   }

   // Hardlinks.
   if ((bkc & kOptBkcFlagBreakhardlink)
       && os_fileinfo_hardlinks(file_info_old) > 1
       && (!file_info_link_ok
           || os_fileinfo_id_equal(&file_info, file_info_old))) {
     *backup_copyp = false;
   }
#endif
 }

 // make sure we have a valid backup extension to use
 char *backup_ext = *p_bex == NUL ? ".bak" : p_bex;

 if (*backup_copyp) {
   bool some_error = false;

   // 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.
   char *dirp = p_bdir;
   while (*dirp) {
     *backupp = buf_get_backup_name(fname, &dirp, no_prepend_dot, backup_ext);
     if (*backupp == NULL) {
       some_error = true;                // out of memory
       goto nobackup;
     }

     FileInfo file_info_new;
     {
       // Check if backup file already exists.
       if (os_fileinfo(*backupp, &file_info_new)) {
         if (os_fileinfo_id_equal(&file_info_new, file_info_old)) {
           //
           // Backup file is same as original file.
           // May happen when modname() gave the same file back (e.g. silly
           // link). If we don't check here, we either ruin the file when
           // copying or erase it after writing.
           //
           XFREE_CLEAR(*backupp);              // no backup file to delete
         } else if (!p_bk) {
           // We are not going to keep the backup file, so don't
           // delete an existing one, and try to use another name instead.
           // Change one character, just before the extension.
           //
           char *wp = *backupp + strlen(*backupp) - 1 - strlen(backup_ext);
           wp = MAX(wp, *backupp);  // empty file name ???
           *wp = 'z';
           while (*wp > 'a' && os_fileinfo(*backupp, &file_info_new)) {
             (*wp)--;
           }
           // They all exist??? Must be something wrong.
           if (*wp == 'a') {
             XFREE_CLEAR(*backupp);
           }
         }
       }
     }

     // Try to create the backup file
     if (*backupp != NULL) {
       // remove old backup, if present
       os_remove(*backupp);

       // copy the file
       if (os_copy(fname, *backupp, UV_FS_COPYFILE_FICLONE) != 0) {
         *err = set_err(_("E509: Cannot create backup file (add ! to override)"));
         XFREE_CLEAR(*backupp);
         *backupp = NULL;
         continue;
       }

       // set file protection same as original file, but
       // strip s-bit.
       os_setperm(*backupp, perm & 0777);

#ifdef UNIX
       // 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 (file_info_new.stat.st_gid != file_info_old->stat.st_gid
           && os_chown(*backupp, (uv_uid_t)-1, (uv_gid_t)file_info_old->stat.st_gid) != 0) {
         os_setperm(*backupp, (perm & 0707) | ((perm & 07) << 3));
       }
       os_file_settime(*backupp,
                       (double)file_info_old->stat.st_atim.tv_sec,
                       (double)file_info_old->stat.st_mtim.tv_sec);
#endif

       os_set_acl(*backupp, acl);
#ifdef HAVE_XATTR
       os_copy_xattr(fname, *backupp);
#endif
       *err = set_err(NULL);
       break;
     }
   }

nobackup:
   if (*backupp == NULL && err->msg == NULL) {
     *err = set_err(_("E509: Cannot create backup file (add ! to override)"));
   }
   // Ignore errors when forceit is true.
   if ((some_error || err->msg != NULL) && !forceit) {
     return FAIL;
   }
   *err = set_err(NULL);
 } else {
   // 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) {
     *err = set_err_num("E504", _(err_readonly));
     return 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.
   char *dirp = p_bdir;
   while (*dirp) {
     *backupp = buf_get_backup_name(fname, &dirp, no_prepend_dot, backup_ext);
     if (*backupp != 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 && os_path_exists(*backupp)) {
         char *p = *backupp + strlen(*backupp) - 1 - strlen(backup_ext);
         p = MAX(p, *backupp);  // empty file name ???
         *p = 'z';
         while (*p > 'a' && os_path_exists(*backupp)) {
           (*p)--;
         }
         // They all exist??? Must be something wrong!
         if (*p == 'a') {
           XFREE_CLEAR(*backupp);
         }
       }
     }
     if (*backupp != 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, *backupp) == 0) {
         break;
       }

       XFREE_CLEAR(*backupp);             // don't do the rename below
     }
   }
   if (*backupp == NULL && !forceit) {
     *err = set_err(_("E510: Can't make backup file (add ! to override)"));
     return FAIL;
   }
 }
 return OK;
}

/// 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()).
///
///
/// @param eap     for forced 'ff' and 'fenc', can be NULL!
/// @param append  append to the file
///
/// @return        FAIL for failure, OK otherwise
int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T end, exarg_T *eap,
             bool append, bool forceit, bool reset_changed, bool filtering)
{
 int retval = OK;
 int msg_save = msg_scroll;
 bool prev_got_int = got_int;
 // writing everything
 bool whole = (start == 1 && end == buf->b_ml.ml_line_count);
 bool write_undo_file = false;
 context_sha256_T sha_ctx;
 unsigned bkc = get_bkc_flags(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_empty_buffer));
   return FAIL;
 }

 // Disallow writing in secure mode.
 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"
 struct bw_info write_info;            // info for buf_write_bytes()
 write_info.bw_conv_buf = NULL;
 write_info.bw_conv_error = false;
 write_info.bw_conv_error_lnum = 0;
 write_info.bw_iconv_fd = (iconv_t)-1;

 // 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
     && !bt_nofilename(buf)
     && !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 Windows, a "cd" in a sub-shell may have moved us to
 // another directory, which we don't detect.
 char *ffname = fname;                           // remember full fname
#ifdef UNIX
 fname = sfname;
#endif

 // true if writing over original
 bool overwriting = buf->b_ffname != NULL && path_fnamecmp(ffname, buf->b_ffname) == 0;

 no_wait_return++;                 // don't wait for return yet

 const pos_T orig_start = buf->b_op_start;
 const pos_T orig_end = buf->b_op_end;

 // 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;

 int res = buf_write_do_autocmds(buf, &fname, &sfname, &ffname, start, &end, eap, append,
                                 filtering, reset_changed, overwriting, whole, orig_start,
                                 orig_end);
 if (res != NOTDONE) {
   return res;
 }

 if (cmdmod.cmod_flags & CMOD_LOCKMARKS) {
   // restore the original '[ and '] positions
   buf->b_op_start = orig_start;
   buf->b_op_end = orig_end;
 }

 if (shortmess(SHM_OVER) && !exiting) {
   msg_scroll = false;             // overwrite previous file message
 } else {
   msg_scroll = true;              // don't overwrite previous file message
 }
 if (!filtering) {
   msg_ext_set_kind("bufwrite");
   // show that we are busy
#ifndef UNIX
   filemess(buf, sfname, "");
#else
   filemess(buf, fname, "");
#endif
 }
 msg_scroll = false;               // always overwrite the file message now

 char *buffer = verbose_try_malloc(WRITEBUFSIZE);
 int bufsize;
 char smallbuf[SMALLBUFSIZE];
 // can't allocate big buffer, use small one (to be able to write when out of
 // memory)
 if (buffer == NULL) {
   buffer = smallbuf;
   bufsize = SMALLBUFSIZE;
 } else {
   bufsize = WRITEBUFSIZE;
 }

 Error_T err = { 0 };
 int perm;              // file permissions
 bool newfile = false;  // true if file doesn't exist yet
 bool device = false;   // writing to a device
 bool file_readonly = false;  // overwritten file is read-only
 char *backup = NULL;
 char *fenc_tofree = NULL;   // allocated "fenc"

 // Get information about original file (if there is one).
 FileInfo file_info_old;

 vim_acl_T acl = NULL;                 // ACL copied from original file to
                                       // backup or new file

 if (get_fileinfo(buf, fname, overwriting, forceit, &file_info_old, &perm, &device, &newfile,
                  &file_readonly, &err) == FAIL) {
   goto fail;
 }

 // For systems that support ACL: get the ACL from the original file.
 if (!newfile) {
   acl = os_get_acl(fname);
 }

 // If 'backupskip' is not empty, don't make a backup for some files.
 bool dobackup = (p_wb || p_bk || *p_pm != NUL);
 if (dobackup && *p_bsk != NUL && match_file_list(p_bsk, sfname, ffname)) {
   dobackup = false;
 }

 bool backup_copy = false;  // copy the original file?

 // 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 (buf_write_make_backup(fname, append, &file_info_old, acl, perm, bkc, file_readonly, forceit,
                             &backup_copy, &backup, &err) == FAIL) {
     retval = FAIL;
     goto fail;
   }
 }

#if defined(UNIX)
 bool made_writable = false;  // 'w' bit has been set

 // When using ":w!" and the file was read-only: make it writable
 if (forceit && perm >= 0 && !(perm & 0200)
     && file_info_old.stat.st_uid == getuid()
     && vim_strchr(p_cpo, CPO_FWRITE) == NULL) {
   perm |= 0200;
   os_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;
   need_maketitle = true;          // set window title later
   status_redraw_all();            // redraw status lines later
 }

 end = MIN(end, buf->b_ml.ml_line_count);
 if (buf->b_ml.ml_flags & ML_EMPTY) {
   start = end + 1;
 }

 char *wfname = NULL;       // name of file to write to

 // 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, !!(buf->b_p_fs >= 0 ? buf->b_p_fs : p_fs));
   if (got_int) {
     err = set_err(_(e_interr));
     goto restore_backup;
   }
 }

 // Default: write the file directly.  May write to a temp file for
 // multi-byte conversion.
 wfname = fname;

 char *fenc;  // effective 'fileencoding'

 // 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.
 bool converted = need_conversion(fenc);
 int wb_flags = 0;

 // 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) {
   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 = (size_t)bufsize * 2;
     } else {       // FIO_UCS4
       write_info.bw_conv_buflen = (size_t)bufsize * 4;
     }
     write_info.bw_conv_buf = verbose_try_malloc(write_info.bw_conv_buflen);
     if (!write_info.bw_conv_buf) {
       end = 0;
     }
   }
 }

 if (converted && wb_flags == 0) {
   // Use iconv() conversion when conversion is needed and it's not done
   // internally.
   write_info.bw_iconv_fd = (iconv_t)my_iconv_open(fenc, "utf-8");
   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 = (size_t)bufsize * ICONV_MULT;
     write_info.bw_conv_buf = verbose_try_malloc(write_info.bw_conv_buflen);
     if (!write_info.bw_conv_buf) {
       end = 0;
     }
     write_info.bw_first = true;
   } else {
     // 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();
       if (wfname == NULL) {  // Can't write without a tempfile!
         err = set_err(_("E214: Can't find temp file for writing"));
         goto restore_backup;
       }
     }
   }
 }

 bool notconverted = false;

 if (converted && wb_flags == 0
     && write_info.bw_iconv_fd == (iconv_t)-1
     && wfname == fname) {
   if (!forceit) {
     err = set_err(_("E213: Cannot convert (add ! to write without conversion)"));
     goto restore_backup;
   }
   notconverted = true;
 }

 bool no_eol = false;  // no end-of-line written
 int nchars;
 linenr_T lnum;
 int fileformat;
 bool checking_conversion;

 int fd;

 // 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 {
     // 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.
     const int fflags = O_WRONLY | (append
                                    ? (forceit ? (O_APPEND | O_CREAT) : O_APPEND)
                                    : (O_CREAT | O_TRUNC));
     const int mode = perm < 0 ? 0666 : (perm & 0777);

     while ((fd = os_open(wfname, fflags, mode)) < 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 os_remove() will fail.
       if (err.msg == NULL) {
#ifdef UNIX
         FileInfo file_info;

         // Don't delete the file when it's a hard or symbolic link.
         if ((!newfile && os_fileinfo_hardlinks(&file_info_old) > 1)
             || (os_fileinfo_link(fname, &file_info)
                 && !os_fileinfo_id_equal(&file_info, &file_info_old))) {
           err = set_err(_("E166: Can't open linked file for writing"));
         } else {
           err = set_err_arg(_("E212: Can't open file for writing: %s"), fd);
           if (forceit && vim_strchr(p_cpo, CPO_FWRITE) == NULL && perm >= 0) {
             // we write to the file, thus it should be marked
             // writable after all
             if (!(perm & 0200)) {
               made_writable = true;
             }
             perm |= 0200;
             if (file_info_old.stat.st_uid != getuid()
                 || file_info_old.stat.st_gid != getgid()) {
               perm &= 0777;
             }
             if (!append) {                    // don't remove when appending
               os_remove(wfname);
             }
             continue;
           }
         }
#else
         err = set_err_arg(_("E212: Can't open file for writing: %s"), fd);
         if (forceit && vim_strchr(p_cpo, CPO_FWRITE) == NULL && perm >= 0) {
           if (!append) {                    // don't remove when appending
             os_remove(wfname);
           }
           continue;
         }
#endif
       }

restore_backup:
       {
         // 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 (!os_path_exists(fname)) {
               vim_rename(backup, fname);
             }
             // if original file does exist throw away the copy
             if (os_path_exists(fname)) {
               os_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 && !os_path_exists(fname)) {
           end = 0;
         }
       }

       if (wfname != fname) {
         xfree(wfname);
       }
       goto fail;
     }
     write_info.bw_fd = fd;
   }
   err = set_err(NULL);

   write_info.bw_buf = buffer;
   nchars = 0;

   // use "++bin", "++nobin" or 'binary'
   int write_bin;
   if (eap != NULL && eap->force_bin != 0) {
     write_bin = (eap->force_bin == FORCE_BIN);
   } else {
     write_bin = buf->b_p_bin;
   }

   // Skip the BOM 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
       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;

   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);
   }

   write_info.bw_len = 0;
   write_info.bw_flags = wb_flags;
   fileformat = get_fileformat_force(buf, eap);
   char *s = buffer;
   for (lnum = start; lnum <= end; lnum++) {
     // The next while loop is done once for each character written.
     // Keep it fast!
     char *ptr = ml_get_buf(buf, lnum) - 1;
     if (write_undo_file) {
       sha256_update(&sha_ctx, (uint8_t *)ptr + 1, (uint32_t)(strlen(ptr + 1) + 1));
     }
     char c;
     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 (++write_info.bw_len != bufsize) {
         continue;
       }
       if (buf_write_bytes(&write_info) == FAIL) {
         end = 0;                        // write error: break loop
         break;
       }
       nchars += bufsize - write_info.bw_len;
       s = buffer + write_info.bw_len;
       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)
             && ((write_bin && 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 (++write_info.bw_len == bufsize) {
           if (buf_write_bytes(&write_info) == FAIL) {
             end = 0;                    // write error: break loop
             break;
           }
           nchars += bufsize - write_info.bw_len;
           s = buffer + write_info.bw_len;
         }
         *s++ = NL;
       }
     }
     if (++write_info.bw_len == bufsize) {
       if (buf_write_bytes(&write_info) == FAIL) {
         end = 0;  // Write error: break loop.
         break;
       }
       nchars += bufsize - write_info.bw_len;
       s = buffer + write_info.bw_len;

       os_breakcheck();
       if (got_int) {
         end = 0;  // Interrupted, break loop.
         break;
       }
     }
   }
   if (write_info.bw_len > 0 && end > 0) {
     int remaining = write_info.bw_len;
     if (buf_write_bytes(&write_info) == FAIL) {
       end = 0;                      // write error
     }
     nchars += remaining - write_info.bw_len;
   }

   // Did we convert & write everything?
   if (end != 0 && write_info.bw_len > 0) {
     write_info.bw_conv_error = true;
     write_info.bw_conv_error_lnum = end;
     end = 0;
   }

   if (!buf->b_p_fixeol && buf->b_p_eof) {
     // write trailing CTRL-Z
     write_eintr(write_info.bw_fd, "\x1a", 1);
   }

   // 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) {
   // 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.
   int error;
   if ((buf->b_p_fs >= 0 ? buf->b_p_fs : p_fs) && (error = os_fsync(fd)) != 0
       // fsync not supported on this storage.
       && error != UV_ENOTSUP && !device) {
     err = set_err_arg(e_fsync, error);
     end = 0;
   }

   if (!backup_copy) {
#ifdef HAVE_XATTR
     os_copy_xattr(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) {
     // don't change the owner when it's already OK, some systems remove
     // permission or ACL stuff
     FileInfo file_info;
     if (!os_fileinfo(wfname, &file_info)
         || file_info.stat.st_uid != file_info_old.stat.st_uid
         || file_info.stat.st_gid != file_info_old.stat.st_gid) {
       os_fchown(fd, (uv_uid_t)file_info_old.stat.st_uid, (uv_gid_t)file_info_old.stat.st_gid);
       if (perm >= 0) {  // Set permission again, may have changed.
         os_setperm(wfname, perm);
       }
     }
     buf_set_file_id(buf);
   } else if (!buf->file_id_valid) {
     // Set the file_id when creating a new file.
     buf_set_file_id(buf);
   }
#endif

   if ((error = os_close(fd)) != 0) {
     err = set_err_arg(_("E512: Close failed: %s"), error);
     end = 0;
   }

#ifdef UNIX
   if (made_writable) {
     perm &= ~0200;              // reset 'w' bit for security reasons
   }
#endif
   if (perm >= 0) {  // Set perm. of new file same as old file.
     os_setperm(wfname, perm);
   }
   // Probably need to set the ACL before changing the user (can't set the
   // ACL on a file the user doesn't own).
   if (!backup_copy) {
     os_set_acl(wfname, acl);
   }

   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("utf-8", fenc, wfname, fname) == FAIL) {
         write_info.bw_conv_error = true;
         end = 0;
       }
     }
     os_remove(wfname);
     xfree(wfname);
   }
 }

 if (end == 0) {
   // Error encountered.
   if (err.msg == NULL) {
     if (write_info.bw_conv_error) {
       if (write_info.bw_conv_error_lnum == 0) {
         err = set_err(_(e_write_error_conversion_failed_make_fenc_empty_to_override));
       } else {
         err = set_err(xmalloc(300));
         err.alloc = true;
         vim_snprintf(err.msg, 300,  // NOLINT(runtime/printf)
                      _(e_write_error_conversion_failed_in_line_nr_make_fenc_empty_to_override),
                      write_info.bw_conv_error_lnum);
       }
     } else if (got_int) {
       err = set_err(_(e_interr));
     } else {
       err = set_err(_(e_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), 0);
         ui_flush();
       }

       // copy the file.
       if (os_copy(backup, fname, UV_FS_COPYFILE_FICLONE)
           == 0) {
         end = 1;  // success
       }
     } 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)
 fname = sfname;           // use shortname now, for the messages
#endif
 if (!filtering) {
   add_quoted_fname(IObuff, IOSIZE, buf, fname);
   bool insert_space = false;
   if (write_info.bw_conv_error) {
     xstrlcat(IObuff, _(" CONVERSION ERROR"), IOSIZE);
     insert_space = true;
     if (write_info.bw_conv_error_lnum != 0) {
       vim_snprintf_add(IObuff, IOSIZE, _(" in line %" PRId64 ";"),
                        (int64_t)write_info.bw_conv_error_lnum);
     }
   } else if (notconverted) {
     xstrlcat(IObuff, _("[NOT converted]"), IOSIZE);
     insert_space = true;
   } else if (converted) {
     xstrlcat(IObuff, _("[converted]"), IOSIZE);
     insert_space = true;
   }
   if (device) {
     xstrlcat(IObuff, _("[Device]"), IOSIZE);
     insert_space = true;
   } else if (newfile) {
     xstrlcat(IObuff, _("[New]"), IOSIZE);
     insert_space = true;
   }
   if (no_eol) {
     xstrlcat(IObuff, _("[noeol]"), IOSIZE);
     insert_space = true;
   }
   // may add [unix/dos/mac]
   if (msg_add_fileformat(fileformat)) {
     insert_space = true;
   }
   msg_add_lines(insert_space, lnum, nchars);       // add line/char count
   if (!shortmess(SHM_WRITE)) {
     if (append) {
       xstrlcat(IObuff, shortmess(SHM_WRI) ? _(" [a]") : _(" appended"), IOSIZE);
     } else {
       xstrlcat(IObuff, shortmess(SHM_WRI) ? _(" [w]") : _(" written"), IOSIZE);
     }
   }

   msg_ext_set_kind("bufwrite");
   msg_ext_overwrite = true;
   set_keep_msg(msg_trunc(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);
   const varnumber_T changedtick = buf_get_changedtick(buf);
   if (buf->b_last_changedtick + 1 == changedtick) {
     // b:changedtick may be incremented in unchanged() but that should not
     // trigger a TextChanged event.
     buf->b_last_changedtick = changedtick;
   }
   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 *const org = modname(fname, p_pm, false);

   if (backup != NULL) {
     // 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 (!os_path_exists(org)) {
       vim_rename(backup, org);
       XFREE_CLEAR(backup);                   // don't delete the file
#ifdef UNIX
       os_file_settime(org,
                       (double)file_info_old.stat.st_atim.tv_sec,
                       (double)file_info_old.stat.st_mtim.tv_sec);
#endif
     }
   } else {
     // If there is no backup file, remember that a (new) file was
     // created.
     int empty_fd;

     if (org == NULL
         || (empty_fd = os_open(org,
                                O_CREAT | O_EXCL | O_NOFOLLOW,
                                perm < 0 ? 0666 : (perm & 0777))) < 0) {
       emsg(_(e_patchmode_cant_touch_empty_original_file));
     } else {
       close(empty_fd);
     }
   }
   if (org != NULL) {
     os_setperm(org, os_getperm(fname) & 0777);
     xfree(org);
   }
 }

 // Remove the backup unless 'backup' option is set
 if (!p_bk && backup != NULL
     && !write_info.bw_conv_error
     && os_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;

 xfree(backup);
 if (buffer != smallbuf) {
   xfree(buffer);
 }
 xfree(fenc_tofree);
 xfree(write_info.bw_conv_buf);
 if (write_info.bw_iconv_fd != (iconv_t)-1) {
   iconv_close(write_info.bw_iconv_fd);
   write_info.bw_iconv_fd = (iconv_t)-1;
 }
 os_free_acl(acl);

 if (err.msg != NULL) {
   // - 100 to save some space for further error message
#ifndef UNIX
   add_quoted_fname(IObuff, IOSIZE - 100, buf, sfname);
#else
   add_quoted_fname(IObuff, IOSIZE - 100, buf, fname);
#endif
   emit_err(&err);

   retval = FAIL;
   if (end == 0) {
     const int hl_id = HLF_E;  // Set highlight for error messages.
     msg_puts_hl(_("\nWARNING: Original file may be lost or damaged\n"), hl_id, true);
     msg_puts_hl(_("don't quit the editor until the file is successfully written!"), hl_id, true);

     // Update the timestamp to avoid an "overwrite changed file"
     // prompt when writing again.
     if (os_fileinfo(fname, &file_info_old)) {
       buf_store_file_info(buf, &file_info_old);
       buf->b_mtime_read = buf->b_mtime;
       buf->b_mtime_read_ns = buf->b_mtime_ns;
     }
   }
 }
 msg_scroll = msg_save;

 // When writing the whole file and 'undofile' is set, also write the undo
 // file.
 if (retval == OK && write_undo_file) {
   uint8_t hash[UNDO_HASH_SIZE];

   sha256_finish(&sha_ctx, hash);
   u_write_undo(NULL, false, buf, hash);
 }

 if (!should_abort(retval)) {
   buf_write_do_post_autocmds(buf, fname, eap, append, filtering, reset_changed, whole);
   if (aborting()) {       // autocmds may abort script processing
     retval = false;
   }
 }

 got_int |= prev_got_int;

 return retval;
}