ops.c: enable -Wconversion warning

13 files changed, 309 insertions, 305 deletions

diff --git a/src/nvim/CMakeLists.txt b/src/nvim/CMakeLists.txt
index ab6f69f66c..20927ec899 100644
--- a/src/nvim/CMakeLists.txt
+++ b/src/nvim/CMakeLists.txt
@@ -95,7 +95,6 @@ set(CONV_SOURCES
   mbyte.c
   memline.c
   message.c
-  ops.c
   regexp.c
   screen.c
   search.c
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index e131da8fe0..74efadc9e4 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -6952,8 +6952,8 @@ static void ins_reg(void)
       AppendCharToRedobuff(literally);
       AppendCharToRedobuff(regname);
 
-      do_put(regname, NULL, BACKWARD, 1L,
-          (literally == Ctrl_P ? PUT_FIXINDENT : 0) | PUT_CURSEND);
+      do_put(regname, NULL, BACKWARD, 1,
+             (literally == Ctrl_P ? PUT_FIXINDENT : 0) | PUT_CURSEND);
     } else if (insert_reg(regname, literally) == FAIL) {
       vim_beep(BO_REG);
       need_redraw = true;  // remove the '"'
@@ -7701,7 +7701,7 @@ static void ins_mouse(int c)
 
   undisplay_dollar();
   tpos = curwin->w_cursor;
-  if (do_mouse(NULL, c, BACKWARD, 1L, 0)) {
+  if (do_mouse(NULL, c, BACKWARD, 1, 0)) {
     win_T   *new_curwin = curwin;
 
     if (curwin != old_curwin && win_valid(old_curwin)) {
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 420a712e3e..dce3556de6 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -1889,7 +1889,7 @@ ex_let_one (
         }
       }
       if (p != NULL) {
-        write_reg_contents(*arg == '@' ? '"' : *arg, p, -1, FALSE);
+        write_reg_contents(*arg == '@' ? '"' : *arg, p, STRLEN(p), false);
         arg_end = arg + 1;
       }
       xfree(ptofree);
@@ -14891,7 +14891,8 @@ static void f_setreg(typval_T *argvars, typval_T *rettv)
     }
     *curval++ = NULL;
 
-    write_reg_contents_lst(regname, lstval, -1, append, yank_type, block_len);
+    write_reg_contents_lst(regname, lstval, STRLEN(lstval),
+                           append, yank_type, block_len);
 
 free_lstval:
     while (curallocval > allocval)
@@ -14902,7 +14903,8 @@ free_lstval:
     if (strval == NULL) {
       return;
     }
-    write_reg_contents_ex(regname, strval, -1, append, yank_type, block_len);
+    write_reg_contents_ex(regname, strval, STRLEN(strval),
+                          append, yank_type, block_len);
   }
   rettv->vval.v_number = 0;
 }
diff --git a/src/nvim/ex_cmds2.c b/src/nvim/ex_cmds2.c
index df4a6d52c4..247f86679f 100644
--- a/src/nvim/ex_cmds2.c
+++ b/src/nvim/ex_cmds2.c
@@ -2010,9 +2010,7 @@ void ex_argdelete(exarg_T *eap)
   maketitle();
 }
 
-/*
- * ":argdo", ":windo", ":bufdo", ":tabdo", ":cdo", ":ldo", ":cfdo" and ":lfdo"
- */
+/// ":argdo", ":windo", ":bufdo", ":tabdo", ":cdo", ":ldo", ":cfdo" and ":lfdo"
 void ex_listdo(exarg_T *eap)
 {
   int i;
@@ -2060,9 +2058,9 @@ void ex_listdo(exarg_T *eap)
     buf_T *buf = curbuf;
     size_t qf_size = 0;
 
-    /* set pcmark now */
+    // set pcmark now
     if (eap->cmdidx == CMD_bufdo) {
-      /* Advance to the first listed buffer after "eap->line1". */
+      // Advance to the first listed buffer after "eap->line1".
       for (buf = firstbuf;
            buf != NULL && (buf->b_fnum < eap->line1 || !buf->b_p_bl);
            buf = buf->b_next) {
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 59962c153b..5096f17df0 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -1536,8 +1536,9 @@ static char_u * do_one_cmd(char_u **cmdlinep,
     }
     ea.cmd = skipwhite(ea.cmd);
     lnum = get_address(&ea, &ea.cmd, ea.addr_type, ea.skip, ea.addr_count == 0);
-    if (ea.cmd == NULL)                     /* error detected */
+    if (ea.cmd == NULL) {  // error detected
       goto doend;
+    }
     if (lnum == MAXLNUM) {
       if (*ea.cmd == '%') {                 /* '%' - all lines */
         ++ea.cmd;
@@ -4640,14 +4641,14 @@ static struct {
   char *name;
 } addr_type_complete[] =
 {
-  {ADDR_ARGUMENTS, "arguments"},
-  {ADDR_LINES, "lines"},
-  {ADDR_LOADED_BUFFERS, "loaded_buffers"},
-  {ADDR_TABS, "tabs"},
-  {ADDR_BUFFERS, "buffers"},
-  {ADDR_WINDOWS, "windows"},
-  {ADDR_QUICKFIX, "quickfix"},
-  {-1, NULL}
+  { ADDR_ARGUMENTS, "arguments" },
+  { ADDR_LINES, "lines" },
+  { ADDR_LOADED_BUFFERS, "loaded_buffers" },
+  { ADDR_TABS, "tabs" },
+  { ADDR_BUFFERS, "buffers" },
+  { ADDR_WINDOWS, "windows" },
+  { ADDR_QUICKFIX, "quickfix" },
+  { -1, NULL }
 };
 
 /*
@@ -7122,8 +7123,8 @@ static void ex_put(exarg_T *eap)
     eap->forceit = TRUE;
   }
   curwin->w_cursor.lnum = eap->line2;
-  do_put(eap->regname, NULL, eap->forceit ? BACKWARD : FORWARD, 1L,
-      PUT_LINE|PUT_CURSLINE);
+  do_put(eap->regname, NULL, eap->forceit ? BACKWARD : FORWARD, 1,
+         PUT_LINE|PUT_CURSLINE);
 }
 
 /*
@@ -7132,7 +7133,7 @@ static void ex_put(exarg_T *eap)
 static void ex_copymove(exarg_T *eap)
 {
   long n = get_address(eap, &eap->arg, eap->addr_type, false, false);
-  if (eap->arg == NULL) {           /* error detected */
+  if (eap->arg == NULL) {  // error detected
     eap->nextcmd = NULL;
     return;
   }
@@ -7351,10 +7352,11 @@ static void ex_redir(exarg_T *eap)
           /* Can use both "@a" and "@a>". */
           if (*arg == '>')
             arg++;
-          /* Make register empty when not using @A-@Z and the
-           * command is valid. */
-          if (*arg == NUL && !isupper(redir_reg))
-            write_reg_contents(redir_reg, (char_u *)"", -1, FALSE);
+          // Make register empty when not using @A-@Z and the
+          // command is valid.
+          if (*arg == NUL && !isupper(redir_reg)) {
+            write_reg_contents(redir_reg, (char_u *)"", 0, false);
+          }
         }
       }
       if (*arg != NUL) {
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index dafb75ca87..9cef1feb35 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -836,8 +836,8 @@ EXTERN int* (*iconv_errno)(void);
 EXTERN int State INIT(= NORMAL);        /* This is the current state of the
                                          * command interpreter. */
 
-EXTERN int finish_op INIT(= FALSE);     /* TRUE while an operator is pending */
-EXTERN long opcount INIT(= 0);          /* count for pending operator */
+EXTERN bool finish_op INIT(= false);    // true while an operator is pending
+EXTERN long opcount INIT(= 0);          // count for pending operator
 
 /*
  * ex mode (Q) state
diff --git a/src/nvim/message.c b/src/nvim/message.c
index 521db85cf0..dd4eedbfb9 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -493,10 +493,11 @@ int emsg(char_u *s)
      * when the message should be ignored completely (used for the
      * interrupt message).
      */
-    if (cause_errthrow(s, severe, &ignore) == TRUE) {
-      if (!ignore)
-        did_emsg = TRUE;
-      return TRUE;
+    if (cause_errthrow(s, severe, &ignore) == true) {
+      if (!ignore) {
+        did_emsg = true;
+      }
+      return true;
     }
 
     // set "v:errmsg", also when using ":silent! cmd"
@@ -511,41 +512,43 @@ int emsg(char_u *s)
       p = get_emsg_source();
       if (p != NULL) {
         STRCAT(p, "\n");
-        redir_write(p, -1);
+        redir_write(p, STRLEN(p));
         xfree(p);
       }
       p = get_emsg_lnum();
       if (p != NULL) {
         STRCAT(p, "\n");
-        redir_write(p, -1);
+        redir_write(p, STRLEN(p));
         xfree(p);
       }
-      redir_write(s, -1);
-      return TRUE;
+      redir_write(s, STRLEN(s));
+      return true;
     }
 
-    /* Reset msg_silent, an error causes messages to be switched back on. */
+    // Reset msg_silent, an error causes messages to be switched back on.
     msg_silent = 0;
     cmd_silent = FALSE;
 
-    if (global_busy)                    /* break :global command */
-      ++global_busy;
+    if (global_busy) {        // break :global command
+      global_busy++;
+    }
 
-    if (p_eb)
-      beep_flush();                     /* also includes flush_buffers() */
-    else
-      flush_buffers(FALSE);             /* flush internal buffers */
-    did_emsg = TRUE;                    /* flag for DoOneCmd() */
+    if (p_eb) {
+      beep_flush();           // also includes flush_buffers()
+    } else {
+      flush_buffers(false);   // flush internal buffers
+    }
+    did_emsg = true;          // flag for DoOneCmd()
   }
 
-  emsg_on_display = TRUE;       /* remember there is an error message */
-  ++msg_scroll;                 /* don't overwrite a previous message */
-  attr = hl_attr(HLF_E);        /* set highlight mode for error messages */
-  if (msg_scrolled != 0)
-    need_wait_return = TRUE;        /* needed in case emsg() is called after
-                                     * wait_return has reset need_wait_return
-                                     * and a redraw is expected because
-                                     * msg_scrolled is non-zero */
+  emsg_on_display = true;     // remember there is an error message
+  msg_scroll++;               // don't overwrite a previous message
+  attr = hl_attr(HLF_E);      // set highlight mode for error messages
+  if (msg_scrolled != 0) {
+    need_wait_return = true;  // needed in case emsg() is called after
+  }                           // wait_return has reset need_wait_return
+                              // and a redraw is expected because
+                              // msg_scrolled is non-zero
 
   /*
    * Display name and line number for the source of the error.
@@ -2401,22 +2404,27 @@ static void redir_write(char_u *str, int maxlen)
     /* If the string doesn't start with CR or NL, go to msg_col */
     if (*s != '\n' && *s != '\r') {
       while (cur_col < msg_col) {
-        if (redir_reg)
-          write_reg_contents(redir_reg, (char_u *)" ", -1, TRUE);
-        else if (redir_vname)
+        if (redir_reg) {
+          write_reg_contents(redir_reg, (char_u *)" ", 1, true);
+        } else if (redir_vname) {
           var_redir_str((char_u *)" ", -1);
-        else if (redir_fd != NULL)
+        } else if (redir_fd != NULL) {
           fputs(" ", redir_fd);
-        if (verbose_fd != NULL)
+        }
+        if (verbose_fd != NULL) {
           fputs(" ", verbose_fd);
-        ++cur_col;
+        }
+        cur_col++;
       }
     }
 
-    if (redir_reg)
-      write_reg_contents(redir_reg, s, maxlen, TRUE);
-    if (redir_vname)
+    if (redir_reg) {
+      size_t len = maxlen == -1 ? STRLEN(s) : (size_t)maxlen;
+      write_reg_contents(redir_reg, s, len, true);
+    }
+    if (redir_vname) {
       var_redir_str(s, maxlen);
+    }
 
     /* Write and adjust the current column. */
     while (*s != NUL && (maxlen < 0 || (int)(s - str) < maxlen)) {
diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c
index 48791384a6..d72d8e8513 100644
--- a/src/nvim/misc1.c
+++ b/src/nvim/misc1.c
@@ -178,12 +178,11 @@ open_line (
   if (curbuf->b_p_ai
       || do_si
       ) {
-    /*
-     * count white space on current line
-     */
-    newindent = get_indent_str(saved_line, (int)curbuf->b_p_ts, FALSE);
-    if (newindent == 0 && !(flags & OPENLINE_COM_LIST))
-      newindent = second_line_indent;       /* for ^^D command in insert mode */
+    // count white space on current line
+    newindent = get_indent_str(saved_line, (int)curbuf->b_p_ts, false);
+    if (newindent == 0 && !(flags & OPENLINE_COM_LIST)) {
+      newindent = second_line_indent;  // for ^^D command in insert mode
+    }
 
     /*
      * Do smart indenting.
@@ -612,7 +611,7 @@ open_line (
         if (curbuf->b_p_ai
             || do_si
             )
-          newindent = get_indent_str(leader, (int)curbuf->b_p_ts, FALSE);
+          newindent = get_indent_str(leader, (int)curbuf->b_p_ts, false);
 
         /* Add the indent offset */
         if (newindent + off < 0) {
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 382c4943ff..573129de25 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -1798,7 +1798,8 @@ void do_pending_operator(cmdarg_T *cap, int old_col, bool gui_yank)
           curbuf->b_ml.ml_line_count)
         beep_flush();
       else {
-        do_join(oap->line_count, oap->op_type == OP_JOIN, true, true, true);
+        do_join((size_t)oap->line_count, oap->op_type == OP_JOIN,
+                true, true, true);
         auto_format(false, true);
       }
       break;
@@ -7666,7 +7667,7 @@ static void nv_join(cmdarg_T *cap)
 
     prep_redo(cap->oap->regname, cap->count0,
               NUL, cap->cmdchar, NUL, NUL, cap->nchar);
-    do_join(cap->count0, cap->nchar == NUL, true, true, true);
+    do_join((size_t)cap->count0, cap->nchar == NUL, true, true, true);
   }
 }
 
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index adfd0424f0..85307f9601 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -1,6 +1,6 @@
 /*
  * ops.c: implementation of various operators: op_shift, op_delete, op_tilde,
- *	  op_change, op_yank, do_put, do_join
+ *        op_change, op_yank, do_put, do_join
  */
 
 #include <assert.h>
@@ -257,8 +257,7 @@ void op_shift(oparg_T *oap, int curs_top, int amount)
  * shift the current line one shiftwidth left (if left != 0) or right
  * leaves cursor on first blank in the line
  */
-void 
-shift_line (
+void shift_line(
     int left,
     int round,
     int amount,
@@ -369,18 +368,18 @@ static void shift_block(oparg_T *oap, int amount)
     memset(newp + bd.textcol + i, ' ', (size_t)j);
     /* the end */
     memmove(newp + bd.textcol + i + j, bd.textstart, (size_t)len);
-  } else { /* left */
-    colnr_T destination_col;            /* column to which text in block will
-                                           be shifted */
-    char_u      *verbatim_copy_end;     /* end of the part of the line which is
-                                           copied verbatim */
-    colnr_T verbatim_copy_width;        /* the (displayed) width of this part
-                                           of line */
-    unsigned fill;                      /* nr of spaces that replace a TAB */
-    unsigned new_line_len;              /* the length of the line after the
-                                           block shift */
-    size_t block_space_width;
-    size_t shift_amount;
+  } else {  // left
+    colnr_T destination_col;      // column to which text in block will
+                                  // be shifted
+    char_u *verbatim_copy_end;    // end of the part of the line which is
+                                  // copied verbatim
+    colnr_T verbatim_copy_width;  // the (displayed) width of this part
+                                  // of line
+    size_t fill;                  // nr of spaces that replace a TAB
+    size_t new_line_len;          // the length of the line after the
+                                  // block shift
+    colnr_T block_space_width;
+    colnr_T shift_amount;
     char_u      *non_white = bd.textstart;
     colnr_T non_white_col;
 
@@ -409,11 +408,10 @@ static void shift_block(oparg_T *oap, int amount)
     block_space_width = non_white_col - oap->start_vcol;
     /* We will shift by "total" or "block_space_width", whichever is less.
      */
-    shift_amount = (block_space_width < (size_t)total
-                    ? block_space_width : (size_t)total);
+    shift_amount = (block_space_width < total ? block_space_width : total);
 
-    /* The column to which we will shift the text.  */
-    destination_col = (colnr_T)(non_white_col - shift_amount);
+    // The column to which we will shift the text.
+    destination_col = non_white_col - shift_amount;
 
     /* Now let's find out how much of the beginning of the line we can
      * reuse without modification.  */
@@ -439,20 +437,21 @@ static void shift_block(oparg_T *oap, int amount)
     /* If "destination_col" is different from the width of the initial
     * part of the line that will be copied, it means we encountered a tab
     * character, which we will have to partly replace with spaces.  */
-    fill = destination_col - verbatim_copy_width;
-
-    /* The replacement line will consist of:
-     * - the beginning of the original line up to "verbatim_copy_end",
-     * - "fill" number of spaces,
-     * - the rest of the line, pointed to by non_white.  */
-    new_line_len = (unsigned)(verbatim_copy_end - oldp)
-                   + fill
-                   + (unsigned)STRLEN(non_white) + 1;
-
-    newp = (char_u *) xmalloc((size_t)(new_line_len));
-    memmove(newp, oldp, (size_t)(verbatim_copy_end - oldp));
-    memset(newp + (verbatim_copy_end - oldp), ' ', (size_t)fill);
-    STRMOVE(newp + (verbatim_copy_end - oldp) + fill, non_white);
+    assert(destination_col - verbatim_copy_width >= 0);
+    fill = (size_t)(destination_col - verbatim_copy_width);
+
+    assert(verbatim_copy_end - oldp >= 0);
+    size_t verbatim_diff = (size_t)(verbatim_copy_end - oldp);
+    // The replacement line will consist of:
+    // - the beginning of the original line up to "verbatim_copy_end",
+    // - "fill" number of spaces,
+    // - the rest of the line, pointed to by non_white.
+    new_line_len = verbatim_diff + fill + STRLEN(non_white) + 1;
+
+    newp = (char_u *) xmalloc(new_line_len);
+    memmove(newp, oldp, verbatim_diff);
+    memset(newp + verbatim_diff, ' ', fill);
+    STRMOVE(newp + verbatim_diff + fill, non_white);
   }
   /* replace the line */
   ml_replace(curwin->w_cursor.lnum, newp, FALSE);
@@ -469,21 +468,20 @@ static void shift_block(oparg_T *oap, int amount)
 static void block_insert(oparg_T *oap, char_u *s, int b_insert, struct block_def *bdp)
 {
   int p_ts;
-  int count = 0;                /* extra spaces to replace a cut TAB */
-  int spaces = 0;               /* non-zero if cutting a TAB */
-  colnr_T offset;               /* pointer along new line */
-  unsigned s_len;               /* STRLEN(s) */
-  char_u      *newp, *oldp;     /* new, old lines */
-  linenr_T lnum;                /* loop var */
+  int count = 0;                // extra spaces to replace a cut TAB
+  int spaces = 0;               // non-zero if cutting a TAB
+  colnr_T offset;               // pointer along new line
+  size_t s_len = STRLEN(s);
+  char_u      *newp, *oldp;     // new, old lines
+  linenr_T lnum;                // loop var
   int oldstate = State;
-
-  State = INSERT;               /* don't want REPLACE for State */
-  s_len = (unsigned)STRLEN(s);
+  State = INSERT;               // don't want REPLACE for State
 
   for (lnum = oap->start.lnum + 1; lnum <= oap->end.lnum; lnum++) {
-    block_prep(oap, bdp, lnum, TRUE);
-    if (bdp->is_short && b_insert)
-      continue;         /* OP_INSERT, line ends before block start */
+    block_prep(oap, bdp, lnum, true);
+    if (bdp->is_short && b_insert) {
+      continue;  // OP_INSERT, line ends before block start
+    }
 
     oldp = ml_get(lnum);
 
@@ -523,25 +521,26 @@ static void block_insert(oparg_T *oap, char_u *s, int b_insert, struct block_def
       count -= off;
     }
 
-    newp = (char_u *) xmalloc((size_t)(STRLEN(oldp) + s_len + count + 1));
+    assert(count >= 0);
+    newp = (char_u *)xmalloc(STRLEN(oldp) + s_len + (size_t)count + 1);
 
-    /* copy up to shifted part */
-    memmove(newp, oldp, (size_t)(offset));
+    // copy up to shifted part
+    memmove(newp, oldp, (size_t)offset);
     oldp += offset;
 
-    /* insert pre-padding */
+    // insert pre-padding
     memset(newp + offset, ' ', (size_t)spaces);
 
-    /* copy the new text */
-    memmove(newp + offset + spaces, s, (size_t)s_len);
-    offset += s_len;
+    // copy the new text
+    memmove(newp + offset + spaces, s, s_len);
+    offset += (int)s_len;
 
     if (spaces && !bdp->is_short) {
-      /* insert post-padding */
+      // insert post-padding
       memset(newp + offset + spaces, ' ', (size_t)(p_ts - spaces));
-      /* We're splitting a TAB, don't copy it. */
+      // We're splitting a TAB, don't copy it.
       oldp++;
-      /* We allowed for that TAB, remember this now */
+      // We allowed for that TAB, remember this now
       count++;
     }
 
@@ -804,7 +803,7 @@ yankreg_T *copy_register(int name)
     copy->y_array = NULL;
   } else {
     copy->y_array = xcalloc(copy->y_size, sizeof(char_u *));
-    for (linenr_T i = 0; i < copy->y_size; i++) {
+    for (size_t i = 0; i < copy->y_size; i++) {
       copy->y_array[i] = vim_strsave(reg->y_array[i]);
     }
   }
@@ -888,7 +887,7 @@ static void set_yreg_additional_data(yankreg_T *reg, dict_T *additional_data)
 
 /*
  * Stuff string "p" into yank register "regname" as a single line (append if
- * uppercase).	"p" must have been alloced.
+ * uppercase). "p" must have been alloced.
  *
  * return FAIL for failure, OK otherwise
  */
@@ -940,10 +939,8 @@ do_execreg (
     int silent                     /* set "silent" flag in typeahead buffer */
 )
 {
-  long i;
-  char_u      *p;
+  char_u *p;
   int retval = OK;
-  int remap;
 
   if (regname == '@') {                 /* repeat previous one */
     if (execreg_lastc == NUL) {
@@ -1001,21 +998,21 @@ do_execreg (
     if (reg->y_array == NULL)
       return FAIL;
 
-    /* Disallow remaping for ":@r". */
-    remap = colon ? REMAP_NONE : REMAP_YES;
+    // Disallow remaping for ":@r".
+    int remap = colon ? REMAP_NONE : REMAP_YES;
 
     /*
      * Insert lines into typeahead buffer, from last one to first one.
      */
     put_reedit_in_typebuf(silent);
-    for (i = reg->y_size - 1; i >= 0; i--) {
-      char_u *escaped;
+    char_u *escaped;
+    for (size_t i = reg->y_size; i-- > 0;) {  // from y_size - 1 to 0 included
 
       // insert NL between lines and after last line if type is kMTLineWise
-      if (reg->y_type == kMTLineWise || i < reg->y_size - 1
-          || addcr) {
-        if (ins_typebuf((char_u *)"\n", remap, 0, TRUE, silent) == FAIL)
+      if (reg->y_type == kMTLineWise || i < reg->y_size - 1 || addcr) {
+        if (ins_typebuf((char_u *)"\n", remap, 0, TRUE, silent) == FAIL) {
           return FAIL;
+        }
       }
       escaped = vim_strsave_escape_csi(reg->y_array[i]);
       retval = ins_typebuf(escaped, remap, 0, TRUE, silent);
@@ -1045,7 +1042,7 @@ static void put_reedit_in_typebuf(int silent)
       buf[1] = 'R';
       buf[2] = NUL;
     } else {
-      buf[0] = restart_edit == 'I' ? 'i' : restart_edit;
+      buf[0] = (char_u)(restart_edit == 'I' ? 'i' : restart_edit);
       buf[1] = NUL;
     }
     if (ins_typebuf(buf, REMAP_NONE, 0, TRUE, silent) == OK)
@@ -1059,8 +1056,7 @@ static void put_reedit_in_typebuf(int silent)
  * When "esc" is TRUE it is to be taken literally: Escape CSI characters and
  * no remapping.
  */
-static int 
-put_in_typebuf (
+static int put_in_typebuf(
     char_u *s,
     int esc,
     int colon,                  /* add ':' before the line */
@@ -1098,13 +1094,11 @@ put_in_typebuf (
  *
  * return FAIL for failure, OK otherwise
  */
-int 
-insert_reg (
+int insert_reg(
     int regname,
     int literally                  /* insert literally, not as if typed */
 )
 {
-  long i;
   int retval = OK;
   char_u      *arg;
   int allocated;
@@ -1132,10 +1126,10 @@ insert_reg (
       xfree(arg);
   } else {                            /* name or number register */
     yankreg_T *reg = get_yank_register(regname, YREG_PASTE);
-    if (reg->y_array == NULL)
+    if (reg->y_array == NULL) {
       retval = FAIL;
-    else {
-      for (i = 0; i < reg->y_size; i++) {
+    } else {
+      for (size_t i = 0; i < reg->y_size; i++) {
         stuffescaped(reg->y_array[i], literally);
         // Insert a newline between lines and after last line if
         // y_type is kMTLineWise.
@@ -1185,8 +1179,7 @@ static void stuffescaped(char_u *arg, int literally)
  * If "regname" is a special register, return TRUE and store a pointer to its
  * value in "argp".
  */
-int 
-get_spec_reg (
+int get_spec_reg(
     int regname,
     char_u **argp,
     int *allocated,         /* return: TRUE when value was allocated */
@@ -1273,13 +1266,11 @@ get_spec_reg (
 /// @returns FAIL for failure, OK otherwise
 bool cmdline_paste_reg(int regname, bool literally, bool remcr)
 {
-  long i;
-
   yankreg_T *reg = get_yank_register(regname, YREG_PASTE);
   if (reg->y_array == NULL)
     return FAIL;
 
-  for (i = 0; i < reg->y_size; i++) {
+  for (size_t i = 0; i < reg->y_size; i++) {
     cmdline_paste_str(reg->y_array[i], literally);
 
     // Insert ^M between lines and after last line if type is kMTLineWise.
@@ -1311,12 +1302,14 @@ int op_delete(oparg_T *oap)
   struct block_def bd;
   linenr_T old_lcount = curbuf->b_ml.ml_line_count;
 
-  if (curbuf->b_ml.ml_flags & ML_EMPTY)             /* nothing to do */
+  if (curbuf->b_ml.ml_flags & ML_EMPTY) {  // nothing to do
     return OK;
+  }
 
-  /* Nothing to delete, return here.	Do prepare undo, for op_change(). */
-  if (oap->empty)
+  // Nothing to delete, return here. Do prepare undo, for op_change().
+  if (oap->empty) {
     return u_save_cursor();
+  }
 
   if (!MODIFIABLE(curbuf)) {
     EMSG(_(e_modifiable));
@@ -1431,23 +1424,21 @@ int op_delete(oparg_T *oap)
         curwin->w_cursor.coladd = 0;
       }
 
-      /* n == number of chars deleted
-       * If we delete a TAB, it may be replaced by several characters.
-       * Thus the number of characters may increase!
-       */
+      // n == number of chars deleted
+      // If we delete a TAB, it may be replaced by several characters.
+      // Thus the number of characters may increase!
       n = bd.textlen - bd.startspaces - bd.endspaces;
       oldp = ml_get(lnum);
-      newp = (char_u *) xmalloc((size_t)(STRLEN(oldp) + 1 - n));
-      /* copy up to deleted part */
+      newp = (char_u *)xmalloc(STRLEN(oldp) - (size_t)n + 1);
+      // copy up to deleted part
       memmove(newp, oldp, (size_t)bd.textcol);
-      /* insert spaces */
-      memset(newp + bd.textcol, ' ',
-          (size_t)(bd.startspaces + bd.endspaces));
-      /* copy the part after the deleted part */
+      // insert spaces
+      memset(newp + bd.textcol, ' ', (size_t)(bd.startspaces + bd.endspaces));
+      // copy the part after the deleted part
       oldp += bd.textcol + bd.textlen;
       STRMOVE(newp + bd.textcol + bd.startspaces + bd.endspaces, oldp);
-      /* replace the line */
-      ml_replace(lnum, newp, FALSE);
+      // replace the line
+      ml_replace(lnum, newp, false);
     }
 
     check_cursor_col();
@@ -1552,7 +1543,7 @@ int op_delete(oparg_T *oap)
           curwin->w_cursor.coladd = 0;
       }
 
-      (void)del_bytes((long)n, !virtual_op,
+      (void)del_bytes((colnr_T)n, !virtual_op,
                       oap->op_type == OP_DELETE && !oap->is_VIsual);
     } else {
       // delete characters between lines
@@ -1572,7 +1563,7 @@ int op_delete(oparg_T *oap)
       // delete from start of line until op_end
       n = (oap->end.col + 1 - !oap->inclusive);
       curwin->w_cursor.col = 0;
-      (void)del_bytes((long)n, !virtual_op,
+      (void)del_bytes((colnr_T)n, !virtual_op,
                       oap->op_type == OP_DELETE && !oap->is_VIsual);
       curwin->w_cursor = curpos;  // restore curwin->w_cursor
       (void)do_join(2, false, false, false, false);
@@ -1611,7 +1602,8 @@ static void mb_adjust_opend(oparg_T *oap)
  */
 static inline void pchar(pos_T lp, int c)
 {
-    *(ml_get_buf(curbuf, lp.lnum, TRUE) + lp.col) = c;;
+    assert(c <= UCHAR_MAX);
+    *(ml_get_buf(curbuf, lp.lnum, true) + lp.col) = (char_u)c;
 }
 
 /*
@@ -1695,15 +1687,16 @@ int op_replace(oparg_T *oap, int c)
 
       oldp = get_cursor_line_ptr();
       oldlen = STRLEN(oldp);
-      newp = (char_u *) xmalloc((size_t)(oldlen + 1 + n));
-      memset(newp, NUL, (size_t)(oldlen + 1 + n));
-      /* copy up to deleted part */
+      assert(n >= 0);
+      newp = (char_u *)xmalloc(oldlen + 1 + (size_t)n);
+      memset(newp, NUL, oldlen + 1 + (size_t)n);
+      // copy up to deleted part
       memmove(newp, oldp, (size_t)bd.textcol);
       oldp += bd.textcol + bd.textlen;
-      /* insert pre-spaces */
+      // insert pre-spaces
       memset(newp + bd.textcol, ' ', (size_t)bd.startspaces);
-      /* insert replacement chars CHECK FOR ALLOCATED SPACE */
-      /* -1/-2 is used for entering CR literally. */
+      // insert replacement chars CHECK FOR ALLOCATED SPACE
+      // -1/-2 is used for entering CR literally.
       if (had_ctrl_v_cr || (c != '\r' && c != '\n')) {
         if (has_mbyte) {
           n = (int)STRLEN(newp);
@@ -1718,8 +1711,8 @@ int op_replace(oparg_T *oap, int c)
           STRMOVE(newp + STRLEN(newp), oldp);
         }
       } else {
-        /* Replacing with \r or \n means splitting the line. */
-        after_p = (char_u *) xmalloc((size_t)(oldlen + 1 + n - STRLEN(newp)));
+        // Replacing with \r or \n means splitting the line.
+        after_p = (char_u *)xmalloc(oldlen + 1 + (size_t)n - STRLEN(newp));
         STRMOVE(after_p, oldp);
       }
       /* replace the line */
@@ -1992,7 +1985,7 @@ void op_insert(oparg_T *oap, long count1)
     // already disabled, but still need it when calling
     // coladvance_force().
     if (curwin->w_cursor.coladd > 0) {
-      int old_ve_flags = ve_flags;
+      unsigned old_ve_flags = ve_flags;
 
       ve_flags = VE_ALL;
       if (u_save_cursor() == FAIL)
@@ -2066,8 +2059,8 @@ void op_insert(oparg_T *oap, long count1)
       if (oap->op_type == OP_INSERT
           && oap->start.col + oap->start.coladd
           != curbuf->b_op_start_orig.col + curbuf->b_op_start_orig.coladd) {
-        size_t t = getviscol2(curbuf->b_op_start_orig.col,
-                              curbuf->b_op_start_orig.coladd);
+        int t = getviscol2(curbuf->b_op_start_orig.col,
+                           curbuf->b_op_start_orig.coladd);
         oap->start.col = curbuf->b_op_start_orig.col;
         pre_textlen -= t - oap->start_vcol;
         oap->start_vcol = t;
@@ -2075,8 +2068,8 @@ void op_insert(oparg_T *oap, long count1)
                  && oap->end.col + oap->end.coladd
                  >= curbuf->b_op_start_orig.col
                  + curbuf->b_op_start_orig.coladd) {
-        size_t t = getviscol2(curbuf->b_op_start_orig.col,
-                              curbuf->b_op_start_orig.coladd);
+        int t = getviscol2(curbuf->b_op_start_orig.col,
+                           curbuf->b_op_start_orig.coladd);
         oap->start.col = curbuf->b_op_start_orig.col;
         /* reset pre_textlen to the value of OP_INSERT */
         pre_textlen += bd.textlen;
@@ -2109,14 +2102,13 @@ void op_insert(oparg_T *oap, long count1)
     firstline = ml_get(oap->start.lnum) + bd.textcol;
     if (oap->op_type == OP_APPEND)
       firstline += bd.textlen;
-    if (pre_textlen >= 0
-        && (ins_len = (long)STRLEN(firstline) - pre_textlen) > 0) {
-      ins_text = vim_strnsave(firstline, (int)ins_len);
-      /* block handled here */
-      if (u_save(oap->start.lnum,
-              (linenr_T)(oap->end.lnum + 1)) == OK)
-        block_insert(oap, ins_text, (oap->op_type == OP_INSERT),
-            &bd);
+    ins_len = (long)STRLEN(firstline) - pre_textlen;
+    if (pre_textlen >= 0 && ins_len > 0) {
+      ins_text = vim_strnsave(firstline, (size_t)ins_len);
+      // block handled here
+      if (u_save(oap->start.lnum, (linenr_T)(oap->end.lnum + 1)) == OK) {
+        block_insert(oap, ins_text, (oap->op_type == OP_INSERT), &bd);
+      }
 
       curwin->w_cursor.col = oap->start.col;
       check_cursor();
@@ -2139,8 +2131,10 @@ int op_change(oparg_T *oap)
   long ins_len;
   long pre_textlen = 0;
   long pre_indent = 0;
-  char_u              *firstline;
-  char_u              *ins_text, *newp, *oldp;
+  char_u *newp;
+  char_u *firstline;
+  char_u *ins_text;
+  char_u *oldp;
   struct block_def bd;
 
   l = oap->start.col;
@@ -2198,14 +2192,14 @@ int op_change(oparg_T *oap)
       long new_indent = (long)(skipwhite(firstline) - firstline);
 
       pre_textlen += new_indent - pre_indent;
-      bd.textcol += new_indent - pre_indent;
+      bd.textcol += (colnr_T)(new_indent - pre_indent);
     }
 
     ins_len = (long)STRLEN(firstline) - pre_textlen;
     if (ins_len > 0) {
       /* Subsequent calls to ml_get() flush the firstline data - take a
        * copy of the inserted text.  */
-      ins_text = (char_u *) xmalloc((size_t)(ins_len + 1));
+      ins_text = (char_u *)xmalloc((size_t)(ins_len + 1));
       STRLCPY(ins_text, firstline + bd.textcol, ins_len + 1);
       for (linenr = oap->st