refactor: format with uncrustify #15726

1 files changed, 1054 insertions, 1032 deletions

diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 2736e9a14f..1a9af639a3 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -20,12 +20,12 @@
 #include "nvim/charset.h"
 #include "nvim/cursor.h"
 #include "nvim/edit.h"
-#include "nvim/eval/userfunc.h"
 #include "nvim/eval.h"
 #include "nvim/eval/encode.h"
 #include "nvim/eval/executor.h"
 #include "nvim/eval/gc.h"
 #include "nvim/eval/typval.h"
+#include "nvim/eval/userfunc.h"
 #include "nvim/ex_cmds2.h"
 #include "nvim/ex_docmd.h"
 #include "nvim/ex_getln.h"
@@ -66,7 +66,7 @@ static char *e_dictrange = N_("E719: Cannot use [:] with a Dictionary");
 static char *e_illvar = N_("E461: Illegal variable name: %s");
 static char *e_cannot_mod = N_("E995: Cannot modify existing variable");
 static char *e_nowhitespace
-    = N_("E274: No white space allowed before parenthesis");
+  = N_("E274: No white space allowed before parenthesis");
 static char *e_invalwindow = N_("E957: Invalid window number");
 static char *e_lock_unlock = N_("E940: Cannot lock or unlock variable %s");
 static char *e_write2 = N_("E80: Error while writing: %s");
@@ -97,7 +97,7 @@ typedef struct {
   dict_T sv_dict;
 } scriptvar_T;
 
-static garray_T ga_scripts = {0, 0, sizeof(scriptvar_T *), 4, NULL};
+static garray_T ga_scripts = { 0, 0, sizeof(scriptvar_T *), 4, NULL };
 #define SCRIPT_SV(id) (((scriptvar_T **)ga_scripts.ga_data)[(id) - 1])
 #define SCRIPT_VARS(id) (SCRIPT_SV(id)->sv_dict.dv_hashtab)
 
@@ -113,7 +113,7 @@ typedef struct {
   int fi_semicolon;             // TRUE if ending in '; var]'
   int fi_varcount;              // nr of variables in the list
   listwatch_T fi_lw;            // keep an eye on the item used.
-  list_T      *fi_list;         // list being used
+  list_T *fi_list;         // list being used
   int fi_bi;                    // index of blob
   blob_T *fi_blob;              // blob being used
 } forinfo_T;
@@ -139,7 +139,7 @@ typedef struct {
 // The reason to use this table anyway is for very quick access to the
 // variables with the VV_ defines.
 static struct vimvar {
-  char        *vv_name;  ///< Name of the variable, without v:.
+  char *vv_name;  ///< Name of the variable, without v:.
   TV_DICTITEM_STRUCT(17) vv_di;  ///< Value and name for key (max 16 chars).
   char vv_flags;  ///< Flags: #VV_COMPAT, #VV_RO, #VV_RO_SBX.
 } vimvars[] =
@@ -334,7 +334,7 @@ void eval_init(void)
 {
   vimvars[VV_VERSION].vv_nr = VIM_VERSION_100;
 
-  struct vimvar   *p;
+  struct vimvar *p;
 
   init_var_dict(&globvardict, &globvars_var, VAR_DEF_SCOPE);
   init_var_dict(&vimvardict, &vimvars_var, VAR_SCOPE);
@@ -346,12 +346,13 @@ void eval_init(void)
     p = &vimvars[i];
     assert(STRLEN(p->vv_name) <= 16);
     STRCPY(p->vv_di.di_key, p->vv_name);
-    if (p->vv_flags & VV_RO)
+    if (p->vv_flags & VV_RO) {
       p->vv_di.di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
-    else if (p->vv_flags & VV_RO_SBX)
+    } else if (p->vv_flags & VV_RO_SBX) {
       p->vv_di.di_flags = DI_FLAGS_RO_SBX | DI_FLAGS_FIX;
-    else
+    } else {
       p->vv_di.di_flags = DI_FLAGS_FIX;
+    }
 
     // add to v: scope dict, unless the value is not always available
     if (p->vv_type != VAR_UNKNOWN) {
@@ -424,7 +425,7 @@ void eval_init(void)
 #if defined(EXITFREE)
 void eval_clear(void)
 {
-  struct vimvar   *p;
+  struct vimvar *p;
 
   for (size_t i = 0; i < ARRAY_SIZE(vimvars); i++) {
     p = &vimvars[i];
@@ -451,10 +452,12 @@ void eval_clear(void)
   /* Script-local variables. First clear all the variables and in a second
    * loop free the scriptvar_T, because a variable in one script might hold
    * a reference to the whole scope of another script. */
-  for (int i = 1; i <= ga_scripts.ga_len; ++i)
+  for (int i = 1; i <= ga_scripts.ga_len; ++i) {
     vars_clear(&SCRIPT_VARS(i));
-  for (int i = 1; i <= ga_scripts.ga_len; ++i)
+  }
+  for (int i = 1; i <= ga_scripts.ga_len; ++i) {
     xfree(SCRIPT_SV(i));
+  }
   ga_clear(&ga_scripts);
 
   // unreferenced lists and dicts
@@ -481,20 +484,16 @@ void set_internal_string_var(const char *name, char_u *value)
   set_var(name, strlen(name), &tv, true);
 }
 
-static lval_T   *redir_lval = NULL;
+static lval_T *redir_lval = NULL;
 static garray_T redir_ga;  // Only valid when redir_lval is not NULL.
 static char_u *redir_endp = NULL;
-static char_u   *redir_varname = NULL;
+static char_u *redir_varname = NULL;
 
-/*
- * Start recording command output to a variable
- * Returns OK if successfully completed the setup.  FAIL otherwise.
- */
-int
-var_redir_start(
-    char_u *name,
-    int append                     // append to an existing variable
-)
+/// Start recording command output to a variable
+/// Returns OK if successfully completed the setup.  FAIL otherwise.
+///
+/// @param append  append to an existing variable
+int var_redir_start(char_u *name, int append)
 {
   int save_emsg;
   int err;
@@ -567,8 +566,9 @@ void var_redir_str(char_u *value, int value_len)
 {
   int len;
 
-  if (redir_lval == NULL)
+  if (redir_lval == NULL) {
     return;
+  }
 
   if (value_len == -1) {
     len = (int)STRLEN(value);           // Append the entire string
@@ -655,8 +655,7 @@ int eval_printexpr(const char *const fname, const char *const args)
   return OK;
 }
 
-void eval_diff(const char *const origfile, const char *const newfile,
-               const char *const outfile)
+void eval_diff(const char *const origfile, const char *const newfile, const char *const outfile)
 {
   bool err = false;
 
@@ -669,8 +668,7 @@ void eval_diff(const char *const origfile, const char *const newfile,
   set_vim_var_string(VV_FNAME_OUT, NULL, -1);
 }
 
-void eval_patch(const char *const origfile, const char *const difffile,
-                const char *const outfile)
+void eval_patch(const char *const origfile, const char *const difffile, const char *const outfile)
 {
   bool err = false;
 
@@ -683,18 +681,13 @@ void eval_patch(const char *const origfile, const char *const difffile,
   set_vim_var_string(VV_FNAME_OUT, NULL, -1);
 }
 
-/*
- * Top level evaluation function, returning a boolean.
- * Sets "error" to TRUE if there was an error.
- * Return TRUE or FALSE.
- */
-int
-eval_to_bool(
-    char_u *arg,
-    bool *error,
-    char_u **nextcmd,
-    int skip                   // only parse, don't execute
-)
+/// Top level evaluation function, returning a boolean.
+/// Sets "error" to TRUE if there was an error.
+///
+/// @param skip  only parse, don't execute
+///
+/// @return  TRUE or FALSE.
+int eval_to_bool(char_u *arg, bool *error, char_u **nextcmd, int skip)
 {
   typval_T tv;
   bool retval = false;
@@ -741,8 +734,7 @@ static int eval1_emsg(char_u **arg, typval_T *rettv, bool evaluate)
   return ret;
 }
 
-int eval_expr_typval(const typval_T *expr, typval_T *argv,
-                     int argc, typval_T *rettv)
+int eval_expr_typval(const typval_T *expr, typval_T *argv, int argc, typval_T *rettv)
   FUNC_ATTR_NONNULL_ARG(1, 2, 4)
 {
   funcexe_T funcexe = FUNCEXE_INIT;
@@ -811,8 +803,7 @@ bool eval_expr_to_bool(const typval_T *expr, bool *error)
 ///
 /// @return [allocated] string result of evaluation or NULL in case of error or
 ///                     when skipping.
-char *eval_to_string_skip(const char *arg, const char **nextcmd,
-                          const bool skip)
+char *eval_to_string_skip(const char *arg, const char **nextcmd, const bool skip)
   FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ARG(1) FUNC_ATTR_WARN_UNUSED_RESULT
 {
   typval_T tv;
@@ -890,7 +881,7 @@ char_u *eval_to_string(char_u *arg, char_u **nextcmd, bool convert)
  */
 char_u *eval_to_string_safe(char_u *arg, char_u **nextcmd, int use_sandbox)
 {
-  char_u      *retval;
+  char_u *retval;
   funccal_entry_T funccal_entry;
 
   save_funccal(&funccal_entry);
@@ -916,7 +907,7 @@ varnumber_T eval_to_number(char_u *expr)
 {
   typval_T rettv;
   varnumber_T retval;
-  char_u      *p = skipwhite(expr);
+  char_u *p = skipwhite(expr);
 
   ++emsg_off;
 
@@ -951,8 +942,9 @@ typval_T *eval_expr(char_u *arg)
 void prepare_vimvar(int idx, typval_T *save_tv)
 {
   *save_tv = vimvars[idx].vv_tv;
-  if (vimvars[idx].vv_type == VAR_UNKNOWN)
+  if (vimvars[idx].vv_type == VAR_UNKNOWN) {
     hash_add(&vimvarht, vimvars[idx].vv_di.di_key);
+  }
 }
 
 /*
@@ -961,7 +953,7 @@ void prepare_vimvar(int idx, typval_T *save_tv)
  */
 void restore_vimvar(int idx, typval_T *save_tv)
 {
-  hashitem_T  *hi;
+  hashitem_T *hi;
 
   vimvars[idx].vv_tv = *save_tv;
   if (vimvars[idx].vv_type == VAR_UNKNOWN) {
@@ -994,15 +986,16 @@ list_T *eval_spell_expr(char_u *badword, char_u *expr)
 {
   typval_T save_val;
   typval_T rettv;
-  list_T      *list = NULL;
-  char_u      *p = skipwhite(expr);
+  list_T *list = NULL;
+  char_u *p = skipwhite(expr);
 
   // Set "v:val" to the bad word.
   prepare_vimvar(VV_VAL, &save_val);
   vimvars[VV_VAL].vv_type = VAR_STRING;
   vimvars[VV_VAL].vv_str = badword;
-  if (p_verbose == 0)
+  if (p_verbose == 0) {
     ++emsg_off;
+  }
 
   if (eval1(&p, &rettv, true) == OK) {
     if (rettv.v_type != VAR_LIST) {
@@ -1012,8 +1005,9 @@ list_T *eval_spell_expr(char_u *badword, char_u *expr)
     }
   }
 
-  if (p_verbose == 0)
+  if (p_verbose == 0) {
     --emsg_off;
+  }
   restore_vimvar(VV_VAL, &save_val);
 
   return list;
@@ -1052,12 +1046,7 @@ int get_spellword(list_T *const list, const char **ret_word)
 // should have type VAR_UNKNOWN.
 //
 // Return OK or FAIL.
-int call_vim_function(
-    const char_u *func,
-    int argc,
-    typval_T *argv,
-    typval_T *rettv
-)
+int call_vim_function(const char_u *func, int argc, typval_T *argv, typval_T *rettv)
   FUNC_ATTR_NONNULL_ALL
 {
   int ret;
@@ -1096,8 +1085,7 @@ fail:
 /// @param[in]  argv  Array with typval_T arguments.
 ///
 /// @return -1 when calling function fails, result of function otherwise.
-varnumber_T call_func_retnr(const char_u *func, int argc,
-                            typval_T *argv)
+varnumber_T call_func_retnr(const char_u *func, int argc, typval_T *argv)
   FUNC_ATTR_NONNULL_ALL
 {
   typval_T rettv;
@@ -1118,8 +1106,7 @@ varnumber_T call_func_retnr(const char_u *func, int argc,
 ///
 /// @return [allocated] NULL when calling function fails, allocated string
 ///                     otherwise.
-char *call_func_retstr(const char *const func, int argc,
-                       typval_T *argv)
+char *call_func_retstr(const char *const func, int argc, typval_T *argv)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_MALLOC
 {
   typval_T rettv;
@@ -1159,14 +1146,12 @@ void *call_func_retlist(const char_u *func, int argc, typval_T *argv)
   return rettv.vval.v_list;
 }
 
-/*
- * Prepare profiling for entering a child or something else that is not
- * counted for the script/function itself.
- * Should always be called in pair with prof_child_exit().
- */
-void prof_child_enter(
-    proftime_T *tm  // place to store waittime
-)
+/// Prepare profiling for entering a child or something else that is not
+/// counted for the script/function itself.
+/// Should always be called in pair with prof_child_exit().
+///
+/// @param tm  place to store waittime
+void prof_child_enter(proftime_T *tm)
 {
   funccall_T *fc = get_current_funccal();
 
@@ -1177,13 +1162,11 @@ void prof_child_enter(
   script_prof_save(tm);
 }
 
-/*
- * Take care of time spent in a child.
- * Should always be called after prof_child_enter().
- */
-void prof_child_exit(
-    proftime_T *tm  // where waittime was stored
-)
+/// Take care of time spent in a child.
+/// Should always be called after prof_child_enter().
+///
+/// @param tm  where waittime was stored
+void prof_child_exit(proftime_T *tm)
 {
   funccall_T *fc = get_current_funccal();
 
@@ -1211,8 +1194,9 @@ int eval_foldexpr(char_u *arg, int *cp)
   int use_sandbox = was_set_insecurely(curwin, (char_u *)"foldexpr", OPT_LOCAL);
 
   ++emsg_off;
-  if (use_sandbox)
+  if (use_sandbox) {
     ++sandbox;
+  }
   ++textlock;
   *cp = NUL;
   if (eval0(arg, &tv, NULL, true) == FAIL) {
@@ -1235,8 +1219,9 @@ int eval_foldexpr(char_u *arg, int *cp)
     tv_clear(&tv);
   }
   --emsg_off;
-  if (use_sandbox)
+  if (use_sandbox) {
     --sandbox;
+  }
   --textlock;
 
   return (int)retval;
@@ -1262,8 +1247,7 @@ void ex_const(exarg_T *eap)
 // marker, then the leading indentation before the lines (matching the
 // indentation in the 'cmd' line) is stripped.
 // Returns a List with {lines} or NULL.
-static list_T *
-heredoc_get(exarg_T *eap, char_u *cmd)
+static list_T *heredoc_get(exarg_T *eap, char_u *cmd)
 {
   char_u *marker;
   char_u *p;
@@ -1327,29 +1311,29 @@ heredoc_get(exarg_T *eap, char_u *cmd)
     // marker
     if (marker_indent_len > 0
         && STRNCMP(theline, *eap->cmdlinep, marker_indent_len) == 0) {
-        mi = marker_indent_len;
+      mi = marker_indent_len;
     }
     if (STRCMP(marker, theline + mi) == 0) {
       xfree(theline);
       break;
     }
     if (text_indent_len == -1 && *theline != NUL) {
-        // set the text indent from the first line.
-        p = theline;
-        text_indent_len = 0;
-        while (ascii_iswhite(*p)) {
-            p++;
-            text_indent_len++;
-        }
-        text_indent = vim_strnsave(theline, text_indent_len);
+      // set the text indent from the first line.
+      p = theline;
+      text_indent_len = 0;
+      while (ascii_iswhite(*p)) {
+        p++;
+        text_indent_len++;
+      }
+      text_indent = vim_strnsave(theline, text_indent_len);
     }
     // with "trim": skip the indent matching the first line
     if (text_indent != NULL) {
-        for (ti = 0; ti < text_indent_len; ti++) {
-            if (theline[ti] != text_indent[ti]) {
-                break;
-            }
+      for (ti = 0; ti < text_indent_len; ti++) {
+        if (theline[ti] != text_indent[ti]) {
+          break;
         }
+      }
     }
 
     tv_list_append_string(l, (char *)(theline + ti), -1);
@@ -1379,14 +1363,14 @@ void ex_let(exarg_T *eap)
 
 static void ex_let_const(exarg_T *eap, const bool is_const)
 {
-  char_u      *arg = eap->arg;
-  char_u      *expr = NULL;
+  char_u *arg = eap->arg;
+  char_u *expr = NULL;
   typval_T rettv;
   int i;
   int var_count = 0;
   int semicolon = 0;
   char_u op[2];
-  char_u      *argend;
+  char_u *argend;
   int first = TRUE;
 
   argend = (char_u *)skip_var_list(arg, &var_count, &semicolon);
@@ -1444,8 +1428,9 @@ static void ex_let_const(exarg_T *eap, const bool is_const)
       expr = skipwhite(expr + 1);
     }
 
-    if (eap->skip)
+    if (eap->skip) {
       ++emsg_skip;
+    }
     i = eval0(expr, &rettv, &eap->nextcmd, !eap->skip);
     if (eap->skip) {
       if (i != FAIL) {
@@ -1460,21 +1445,20 @@ static void ex_let_const(exarg_T *eap, const bool is_const)
   }
 }
 
-/*
- * Assign the typevalue "tv" to the variable or variables at "arg_start".
- * Handles both "var" with any type and "[var, var; var]" with a list type.
- * When "op" is not NULL it points to a string with characters that
- * must appear after the variable(s).  Use "+", "-" or "." for add, subtract
- * or concatenate.
- * Returns OK or FAIL;
- */
-static int ex_let_vars(char_u *arg_start,
-                       typval_T *tv,
-                       int copy,       // copy values from "tv", don't move
-                       int semicolon,  // from skip_var_list()
-                       int var_count,  // from skip_var_list()
-                       int is_const,   // lock variables for :const
-                       char_u *op)
+/// Assign the typevalue "tv" to the variable or variables at "arg_start".
+/// Handles both "var" with any type and "[var, var; var]" with a list type.
+/// When "op" is not NULL it points to a string with characters that
+/// must appear after the variable(s).  Use "+", "-" or "." for add, subtract
+/// or concatenate.
+///
+/// @param copy  copy values from "tv", don't move
+/// @param semicolon  from skip_var_list()
+/// @param var_count  from skip_var_list()
+/// @param is_const  lock variables for :const
+///
+/// @return  OK or FAIL;
+static int ex_let_vars(char_u *arg_start, typval_T *tv, int copy, int semicolon, int var_count,
+                       int is_const, char_u *op)
 {
   char_u *arg = arg_start;
   typval_T ltv;
@@ -1559,8 +1543,7 @@ static int ex_let_vars(char_u *arg_start,
  * for "[var, var; var]" set "semicolon".
  * Return NULL for an error.
  */
-static const char_u *skip_var_list(const char_u *arg, int *var_count,
-                                   int *semicolon)
+static const char_u *skip_var_list(const char_u *arg, int *var_count, int *semicolon)
 {
   const char_u *p;
   const char_u *s;
@@ -1578,9 +1561,9 @@ static const char_u *skip_var_list(const char_u *arg, int *var_count,
       ++*var_count;
 
       p = skipwhite(s);
-      if (*p == ']')
+      if (*p == ']') {
         break;
-      else if (*p == ';') {
+      } else if (*p == ';') {
         if (*semicolon == 1) {
           EMSG(_("E452: Double ; in list of variables"));
           return NULL;
@@ -1592,8 +1575,9 @@ static const char_u *skip_var_list(const char_u *arg, int *var_count,
       }
     }
     return p + 1;
-  } else
+  } else {
     return skip_var_one(arg);
+  }
 }
 
 /*
@@ -1602,21 +1586,21 @@ static const char_u *skip_var_list(const char_u *arg, int *var_count,
  */
 static const char_u *skip_var_one(const char_u *arg)
 {
-  if (*arg == '@' && arg[1] != NUL)
+  if (*arg == '@' && arg[1] != NUL) {
     return arg + 2;
+  }
   return find_name_end(*arg == '$' || *arg == '&' ? arg + 1 : arg,
-      NULL, NULL, FNE_INCL_BR | FNE_CHECK_START);
+                       NULL, NULL, FNE_INCL_BR | FNE_CHECK_START);
 }
 
 /*
  * List variables for hashtab "ht" with prefix "prefix".
  * If "empty" is TRUE also list NULL strings as empty strings.
  */
-void list_hashtable_vars(hashtab_T *ht, const char *prefix, int empty,
-                         int *first)
+void list_hashtable_vars(hashtab_T *ht, const char *prefix, int empty, int *first)
 {
-  hashitem_T  *hi;
-  dictitem_T  *di;
+  hashitem_T *hi;
+  dictitem_T *di;
   int todo;
 
   todo = (int)ht->ht_used;
@@ -1740,13 +1724,20 @@ static const char *list_arg_vars(exarg_T *eap, const char *arg, int *first)
           } else {
             if (arg == arg_subsc && len == 2 && name[1] == ':') {
               switch (*name) {
-              case 'g': list_glob_vars(first); break;
-              case 'b': list_buf_vars(first); break;
-              case 'w': list_win_vars(first); break;
-              case 't': list_tab_vars(first); break;
-              case 'v': list_vim_vars(first); break;
-              case 's': list_script_vars(first); break;
-              case 'l': list_func_vars(first); break;
+              case 'g':
+                list_glob_vars(first); break;
+              case 'b':
+                list_buf_vars(first); break;
+              case 'w':
+                list_win_vars(first); break;
+              case 't':
+                list_tab_vars(first); break;
+              case 'v':
+                list_vim_vars(first); break;
+              case 's':
+                list_script_vars(first); break;
+              case 'l':
+                list_func_vars(first); break;
               default:
                 EMSG2(_("E738: Can't list variables for %s"), name);
               }
@@ -1789,8 +1780,7 @@ static const char *list_arg_vars(exarg_T *eap, const char *arg, int *first)
 ///
 /// @return a pointer to the char just after the var name or NULL in case of
 ///         error.
-static char_u *ex_let_one(char_u *arg, typval_T *const tv,
-                          const bool copy, const bool is_const,
+static char_u *ex_let_one(char_u *arg, typval_T *const tv, const bool copy, const bool is_const,
                           const char_u *const endchars, const char_u *const op)
   FUNC_ATTR_NONNULL_ARG(1, 2) FUNC_ATTR_WARN_UNUSED_RESULT
 {
@@ -1848,9 +1838,9 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
         xfree(tofree);
       }
     }
-  // ":let &option = expr": Set option value.
-  // ":let &l:option = expr": Set local option value.
-  // ":let &g:option = expr": Set global option value.
+    // ":let &option = expr": Set option value.
+    // ":let &l:option = expr": Set local option value.
+    // ":let &g:option = expr": Set global option value.
   } else if (*arg == '&') {
     if (is_const) {
       EMSG(_("E996: Cannot lock an option"));
@@ -1885,11 +1875,16 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
         } else {
           if (opt_type == 1) {  // number
             switch (*op) {
-              case '+': n = numval + n; break;
-              case '-': n = numval - n; break;
-              case '*': n = numval * n; break;
-              case '/': n = num_divide(numval, n); break;
-              case '%': n = num_modulus(numval, n); break;
+            case '+':
+              n = numval + n; break;
+            case '-':
+              n = numval - n; break;
+            case '*':
+              n = numval * n; break;
+            case '/':
+              n = num_divide(numval, n); break;
+            case '%':
+              n = num_modulus(numval, n); break;
             }
           } else if (opt_type == 0 && stringval != NULL) {  // string
             char *const oldstringval = stringval;
@@ -1908,7 +1903,7 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
       *p = c1;
       xfree(stringval);
     }
-  // ":let @r = expr": Set register contents.
+    // ":let @r = expr": Set register contents.
   } else if (*arg == '@') {
     if (is_const) {
       EMSG(_("E996: Cannot lock a register"));
@@ -1921,7 +1916,7 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
                && vim_strchr(endchars, *skipwhite(arg + 1)) == NULL) {
       EMSG(_(e_letunexp));
     } else {
-      char_u      *s;
+      char_u *s;
 
       char_u *ptofree = NULL;
       const char *p = tv_get_string_chk(tv);
@@ -1958,8 +1953,9 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
       }
     }
     clear_lval(&lv);
-  } else
+  } else {
     EMSG2(_(e_invarg2), arg);
+  }
 
   return arg_end;
 }
@@ -1989,16 +1985,15 @@ static char_u *ex_let_one(char_u *arg, typval_T *const tv,
 ///
 /// @return A pointer to just after the name, including indexes. Returns NULL
 ///         for a parsing error, but it is still needed to free items in lp.
-char_u *get_lval(char_u *const name, typval_T *const rettv,
-                 lval_T *const lp, const bool unlet, const bool skip,
-                 const int flags, const int fne_flags)
+char_u *get_lval(char_u *const name, typval_T *const rettv, lval_T *const lp, const bool unlet,
+                 const bool skip, const int flags, const int fne_flags)
   FUNC_ATTR_NONNULL_ARG(1, 3)
 {
-  dictitem_T  *v;
+  dictitem_T *v;
   typval_T var1;
   typval_T var2;
   int empty1 = FALSE;
-  listitem_T  *ni;
+  listitem_T *ni;
   hashtab_T *ht = NULL;
   int quiet = flags & GLV_QUIET;
 
@@ -2080,8 +2075,9 @@ char_u *get_lval(char_u *const name, typval_T *const rettv,
       return NULL;
     }
     if (lp->ll_range) {
-      if (!quiet)
+      if (!quiet) {
         EMSG(_("E708: [:] must come last"));
+      }
       return NULL;
     }
 
@@ -2233,7 +2229,7 @@ char_u *get_lval(char_u *const name, typval_T *const rettv,
         }
         tv_clear(&var1);
         break;
-      // existing variable, need to check if it can be changed
+        // existing variable, need to check if it can be changed
       } else if (!(flags & GLV_READ_ONLY) && var_check_ro(lp->ll_di->di_flags,
                                                           (const char *)name,
                                                           (size_t)(p - name))) {
@@ -2312,8 +2308,9 @@ char_u *get_lval(char_u *const name, typval_T *const rettv,
         if (lp->ll_n2 < 0) {
           ni = tv_list_find(lp->ll_list, lp->ll_n2);
           if (ni == NULL) {
-            if (!quiet)
+            if (!quiet) {
               EMSGN(_(e_listidx), lp->ll_n2);
+            }
             return NULL;
           }
           lp->ll_n2 = tv_list_idx_of_item(lp->ll_list, ni);
@@ -2358,12 +2355,12 @@ void clear_lval(lval_T *lp)
  * "op" is NULL, "+" for "+=", "-" for "-=", "*" for "*=", "/" for "/=",
  * "%" for "%=", "." for ".=" or "=" for "=".
  */
-static void set_var_lval(lval_T *lp, char_u *endp, typval_T *rettv,
-                         int copy, const bool is_const, const char *op)
+static void set_var_lval(lval_T *lp, char_u *endp, typval_T *rettv, int copy, const bool is_const,
+                         const char *op)
 {
   int cc;
-  listitem_T  *ri;
-  dictitem_T  *di;
+  listitem_T *ri;
+  dictitem_T *di;
 
   if (lp->ll_tv == NULL) {
     cc = *endp;
@@ -2568,16 +2565,17 @@ notify:
  */
 void *eval_for_line(const char_u *arg, bool *errp, char_u **nextcmdp, int skip)
 {
-  forinfo_T   *fi = xcalloc(1, sizeof(forinfo_T));
+  forinfo_T *fi = xcalloc(1, sizeof(forinfo_T));
   const char_u *expr;
   typval_T tv;
-  list_T      *l;
+  list_T *l;
 
   *errp = true;  // Default: there is an error.
 
   expr = skip_var_list(arg, &fi->fi_varcount, &fi->fi_semicolon);
-  if (expr == NULL)
+  if (expr == NULL) {
     return fi;
+  }
 
   expr = skipwhite(expr);
   if (expr[0] != 'i' || expr[1] != 'n' || !ascii_iswhite(expr[2])) {
@@ -2585,8 +2583,9 @@ void *eval_for_line(const char_u *arg, bool *errp, char_u **nextcmdp, int skip)
     return fi;
   }
 
-  if (skip)
+  if (skip) {
     ++emsg_skip;
+  }
   if (eval0(skipwhite(expr + 2), &tv, nextcmdp, !skip) == OK) {
     *errp = false;
     if (!skip) {
@@ -2619,8 +2618,9 @@ void *eval_for_line(const char_u *arg, bool *errp, char_u **nextcmdp, int skip)
       }
     }
   }
-  if (skip)
+  if (skip) {
     --emsg_skip;
+  }
 
   return fi;
 }
@@ -2667,7 +2667,7 @@ bool next_for_item(void *fi_void, char_u *arg)
  */
 void free_for_info(void *fi_void)
 {
-  forinfo_T    *fi = (forinfo_T *)fi_void;
+  forinfo_T *fi = (forinfo_T *)fi_void;
 
   if (fi != NULL && fi->fi_list != NULL) {
     tv_list_watch_remove(fi->fi_list, &fi->fi_lw);
@@ -2685,7 +2685,7 @@ void set_context_for_expression(expand_T *xp, char_u *arg, cmdidx_T cmdidx)
 {
   int got_eq = FALSE;
   int c;
-  char_u      *p;
+  char_u *p;
 
   if (cmdidx == CMD_let || cmdidx == CMD_const) {
     xp->xp_context = EXPAND_USER_VARS;
@@ -2700,11 +2700,12 @@ void set_context_for_expression(expand_T *xp, char_u *arg, cmdidx_T cmdidx)
       }
       return;
     }
-  } else
+  } else {
     xp->xp_context = cmdidx == CMD_call ? EXPAND_FUNCTIONS
-                     : EXPAND_EXPRESSION;
+                                        : EXPAND_EXPRESSION;
+  }
   while ((xp->xp_pattern = vim_strpbrk(arg,
-              (char_u *)"\"'+-*/%.=!?~|&$([<>,#")) != NULL) {
+                                       (char_u *)"\"'+-*/%.=!?~|&$([<>,#")) != NULL) {
     c = *xp->xp_pattern;
     if (c == '&') {
       c = xp->xp_pattern[1];
@@ -2714,9 +2715,9 @@ void set_context_for_expression(expand_T *xp, char_u *arg, cmdidx_T cmdidx)
                          ? EXPAND_EXPRESSION : EXPAND_NOTHING;
       } else if (c != ' ') {
         xp->xp_context = EXPAND_SETTINGS;
-        if ((c == 'l' || c == 'g') && xp->xp_pattern[2] == ':')
+        if ((c == 'l' || c == 'g') && xp->xp_pattern[2] == ':') {
           xp->xp_pattern += 2;
-
+        }
       }
     } else if (c == '$') {
       // environment variable
@@ -2750,14 +2751,17 @@ void set_context_for_expression(expand_T *xp, char_u *arg, cmdidx_T cmdidx)
         if (xp->xp_pattern[1] == '|') {
           ++xp->xp_pattern;
           xp->xp_context = EXPAND_EXPRESSION;
-        } else
+        } else {
           xp->xp_context = EXPAND_COMMANDS;
-      } else
+        }
+      } else {
         xp->xp_context = EXPAND_EXPRESSION;
-    } else
+      }
+    } else {
       /* Doesn't look like something valid, expand as an expression
        * anyway. */
       xp->xp_context = EXPAND_EXPRESSION;
+    }
     arg = xp->xp_pattern;
     if (*arg != NUL) {
       while ((c = *++arg) != NUL && (c == ' ' || c == '\t')) {
@@ -2819,8 +2823,7 @@ void ex_lockvar(exarg_T *eap)
 /// @param[in]  deep  Levels to (un)lock for :(un)lockvar, -1 to (un)lock
 ///                   everything.
 /// @param[in]  callback  Appropriate handler for the command.
-static void ex_unletlock(exarg_T *eap, char_u *argstart, int deep,
-                         ex_unletlock_callback callback)
+static void ex_unletlock(exarg_T *eap, char_u *argstart, int deep, ex_unletlock_callback callback)
   FUNC_ATTR_NONNULL_ALL
 {
   char_u *arg = argstart;
@@ -2884,8 +2887,7 @@ static void ex_unletlock(exarg_T *eap, char_u *argstart, int deep,
 /// @param[in]  deep  Unused.
 ///
 /// @return OK on success, or FAIL on failure.
-static int do_unlet_var(lval_T *lp, char_u *name_end, exarg_T *eap,
-                        int deep FUNC_ATTR_UNUSED)
+static int do_unlet_var(lval_T *lp, char_u *name_end, exarg_T *eap, int deep FUNC_ATTR_UNUSED)
   FUNC_ATTR_NONNULL_ALL
 {
   int forceit = eap->forceit;
@@ -2989,7 +2991,7 @@ int do_unlet(const char *const name, const size_t name_len, const bool forceit)
       if (ht == &globvarht) {
         d = &globvardict;
       } else if (ht == &compat_hashtab) {
-          d = &vimvardict;
+        d = &vimvardict;
       } else {
         dictitem_T *const di = find_var_in_ht(ht, *name, "", 0, false);
         d = di->di_tv.vval.v_dict;
@@ -3032,8 +3034,9 @@ int do_unlet(const char *const name, const size_t name_len, const bool forceit)
       return OK;
     }
   }
-  if (forceit)
+  if (forceit) {
     return OK;
+  }
   EMSG2(_("E108: No such variable: \"%s\""), name);
   return FAIL;
 }
@@ -3050,8 +3053,7 @@ int do_unlet(const char *const name, const size_t name_len, const bool forceit)
 /// @param[in]  deep  Levels to (un)lock, -1 to (un)lock everything.
 ///
 /// @return OK on success, or FAIL on failure.
-static int do_lock_var(lval_T *lp, char_u *name_end FUNC_ATTR_UNUSED,
-                       exarg_T *eap, int deep)
+static int do_lock_var(lval_T *lp, char_u *name_end FUNC_ATTR_UNUSED, exarg_T *eap, int deep)
   FUNC_ATTR_NONNULL_ARG(1, 3)
 {
   bool lock = eap->cmdidx == CMD_lockvar;
@@ -3067,9 +3069,8 @@ static int do_lock_var(lval_T *lp, char_u *name_end FUNC_ATTR_UNUSED,
       ret = FAIL;
     } else {
       // Normal name or expanded name.
-      dictitem_T *const di = find_var(
-          (const char *)lp->ll_name, lp->ll_name_len, NULL,
-          true);
+      dictitem_T *const di = find_var((const char *)lp->ll_name, lp->ll_name_len, NULL,
+                                      true);
       if (di == NULL) {
         ret = FAIL;
       } else if ((di->di_flags & DI_FLAGS_FIX)
@@ -3089,7 +3090,7 @@ static int do_lock_var(lval_T *lp, char_u *name_end FUNC_ATTR_UNUSED,
       }
     }
   } else if (lp->ll_range) {
-    listitem_T    *li = lp->ll_li;
+    listitem_T *li = lp->ll_li;
 
     // (un)lock a range of List items.
     while (li != NULL && (lp->ll_empty2 || lp->ll_n2 >= lp->ll_n1)) {
@@ -3129,7 +3130,7 @@ void del_menutrans_vars(void)
  */
 
 
-static char_u   *varnamebuf = NULL;
+static char_u *varnamebuf = NULL;
 static size_t varnamebuflen = 0;
 
 /*
@@ -3163,7 +3164,7 @@ char_u *get_user_var_name(expand_T *xp, int idx)
   static size_t wdone;
   static size_t tdone;
   static size_t vidx;
-  static hashitem_T   *hi;
+  static hashitem_T *hi;
 
   if (idx == 0) {
     gdone = bdone = wdone = vidx = 0;
@@ -3172,14 +3173,17 @@ char_u *get_user_var_name(expand_T *xp, int idx)
 
   // Global variables
   if (gdone < globvarht.ht_used) {
-    if (gdone++ == 0)
+    if (gdone++ == 0) {
       hi = globvarht.ht_array;
-    else
+    } else {
       ++hi;
-    while (HASHITEM_EMPTY(hi))
+    }
+    while (HASHITEM_EMPTY(hi)) {
       ++hi;
-    if (STRNCMP("g:", xp->xp_pattern, 2) == 0)
+    }
+    if (STRNCMP("g:", xp->xp_pattern, 2) == 0) {
       return cat_prefix_varname('g', hi->hi_key);
+    }
     return hi->hi_key;
   }
 
@@ -3189,12 +3193,14 @@ char_u *get_user_var_name(expand_T *xp, int idx)
     ? &prevwin->w_buffer->b_vars->dv_hashtab
     : &curbuf->b_vars->dv_hashtab;
   if (bdone < ht->ht_used) {
-    if (bdone++ == 0)
+    if (bdone++ == 0) {
       hi = ht->ht_array;
-    else
+    } else {
       ++hi;
-    while (HASHITEM_EMPTY(hi))
+    }
+    while (HASHITEM_EMPTY(hi)) {
       ++hi;
+    }
     return cat_prefix_varname('b', hi->hi_key);
   }
 
@@ -3204,24 +3210,28 @@ char_u *get_user_var_name(expand_T *xp, int idx)
     ? &prevwin->w_vars->dv_hashtab
     : &curwin->w_vars->dv_hashtab;
   if (wdone < ht->ht_used) {
-    if (wdone++ == 0)
+    if (wdone++ == 0) {
       hi = ht->ht_array;
-    else
+    } else {
       ++hi;
-    while (HASHITEM_EMPTY(hi))
+    }
+    while (HASHITEM_EMPTY(hi)) {
       ++hi;
+    }
     return cat_prefix_varname('w', hi->hi_key);
   }
 
   // t: variables
   ht = &curtab->tp_vars->dv_hashtab;
   if (tdone < ht->ht_used) {
-    if (tdone++ == 0)
+    if (tdone++ == 0) {
       hi = ht->ht_array;
-    else
+    } else {
       ++hi;
-    while (HASHITEM_EMPTY(hi))
+    }
+    while (HASHITEM_EMPTY(hi)) {
       ++hi;
+    }
     return cat_prefix_varname('t', hi->hi_key);
   }
 
@@ -3265,8 +3275,7 @@ static int pattern_match(char_u *pat, char_u *text, bool ic)
 //
 /// @return OK or FAIL.
 static int eval_func(char_u **const arg, char_u *const name, const int name_len,
-                     typval_T *const rettv, const bool evaluate,
-                     typval_T *const basetv)
+                     typval_T *const rettv, const bool evaluate, typval_T *const basetv)
   FUNC_ATTR_NONNULL_ARG(1, 2, 4)
 {
   char_u *s = name;
@@ -3334,7 +3343,7 @@ static int eval_func(char_u **const arg, char_u *const name, const int name_len,
 int eval0(char_u *arg, typval_T *rettv, char_u **nextcmd, int evaluate)
 {
   int ret;
-  char_u      *p;
+  char_u *p;
   const int did_emsg_before = did_emsg;
   const int called_emsg_before = called_emsg;
 
@@ -3354,8 +3363,9 @@ int eval0(char_u *arg, typval_T *rettv, char_u **nextcmd, int evaluate)
     }
     ret = FAIL;
   }
-  if (nextcmd != NULL)
+  if (nextcmd != NULL) {
     *nextcmd = check_nextcmd(p);
+  }
 
   return ret;
 }