refactor: format files with uncrustify #15607

11 files changed, 4107 insertions, 3581 deletions

diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index ffe60ab043..8216987635 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -6,60 +6,60 @@
  */
 
 #include <assert.h>
-#include <string.h>
 #include <inttypes.h>
 #include <stdbool.h>
+#include <string.h>
 
-#include "nvim/vim.h"
 #include "nvim/ascii.h"
-#include "nvim/edit.h"
 #include "nvim/buffer.h"
 #include "nvim/change.h"
 #include "nvim/charset.h"
 #include "nvim/cursor.h"
 #include "nvim/digraph.h"
+#include "nvim/edit.h"
 #include "nvim/eval.h"
 #include "nvim/eval/typval.h"
+#include "nvim/event/loop.h"
 #include "nvim/ex_docmd.h"
 #include "nvim/ex_getln.h"
+#include "nvim/extmark.h"
 #include "nvim/fileio.h"
 #include "nvim/fold.h"
 #include "nvim/getchar.h"
 #include "nvim/indent.h"
 #include "nvim/indent_c.h"
+#include "nvim/keymap.h"
 #include "nvim/main.h"
-#include "nvim/extmark.h"
+#include "nvim/mark.h"
 #include "nvim/mbyte.h"
 #include "nvim/memline.h"
 #include "nvim/memory.h"
 #include "nvim/message.h"
 #include "nvim/misc1.h"
-#include "nvim/keymap.h"
+#include "nvim/mouse.h"
 #include "nvim/move.h"
 #include "nvim/normal.h"
 #include "nvim/ops.h"
 #include "nvim/option.h"
+#include "nvim/os/input.h"
+#include "nvim/os/time.h"
 #include "nvim/path.h"
-#include "nvim/popupmnu.h"
 #include "nvim/plines.h"
+#include "nvim/popupmnu.h"
 #include "nvim/quickfix.h"
 #include "nvim/regexp.h"
 #include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/spell.h"
-#include "nvim/strings.h"
 #include "nvim/state.h"
+#include "nvim/strings.h"
 #include "nvim/syntax.h"
 #include "nvim/tag.h"
-#include "nvim/ui.h"
-#include "nvim/mouse.h"
 #include "nvim/terminal.h"
+#include "nvim/ui.h"
 #include "nvim/undo.h"
+#include "nvim/vim.h"
 #include "nvim/window.h"
-#include "nvim/event/loop.h"
-#include "nvim/mark.h"
-#include "nvim/os/input.h"
-#include "nvim/os/time.h"
 
 // Definitions used for CTRL-X submode.
 // Note: If you change CTRL-X submode, you must also maintain ctrl_x_msgs[]
@@ -140,13 +140,13 @@ static char e_compldel[] = N_("E840: Completion function deleted text");
  */
 typedef struct compl_S compl_T;
 struct compl_S {
-  compl_T     *cp_next;
-  compl_T     *cp_prev;
-  char_u      *cp_str;          // matched text
-  char_u      *(cp_text[CPT_COUNT]);    // text for the menu
+  compl_T *cp_next;
+  compl_T *cp_prev;
+  char_u *cp_str;          // matched text
+  char_u *(cp_text[CPT_COUNT]);    // text for the menu
   typval_T    cp_user_data;
-  char_u      *cp_fname;        // file containing the match, allocated when
-                                // cp_flags has CP_FREE_FNAME
+  char_u *cp_fname;        // file containing the match, allocated when
+                           // cp_flags has CP_FREE_FNAME
   int cp_flags;                 // CP_ values
   int cp_number;                // sequence number
 };
@@ -158,10 +158,10 @@ struct compl_S {
  * "compl_shown_match" is different from compl_curr_match during
  * ins_compl_get_exp().
  */
-static compl_T    *compl_first_match = NULL;
-static compl_T    *compl_curr_match = NULL;
-static compl_T    *compl_shown_match = NULL;
-static compl_T    *compl_old_match = NULL;
+static compl_T *compl_first_match = NULL;
+static compl_T *compl_curr_match = NULL;
+static compl_T *compl_shown_match = NULL;
+static compl_T *compl_old_match = NULL;
 
 /* After using a cursor key <Enter> selects a match in the popup menu,
  * otherwise it inserts a line break. */
@@ -169,7 +169,7 @@ static int compl_enter_selects = FALSE;
 
 /* When "compl_leader" is not NULL only matches that start with this string
  * are used. */
-static char_u     *compl_leader = NULL;
+static char_u *compl_leader = NULL;
 
 static int compl_get_longest = FALSE;           /* put longest common string
                                                    in compl_leader */
@@ -196,15 +196,15 @@ static bool compl_started = false;
 static int ctrl_x_mode = CTRL_X_NORMAL;
 
 static int compl_matches = 0;
-static char_u     *compl_pattern = NULL;
+static char_u *compl_pattern = NULL;
 static Direction compl_direction = FORWARD;
 static Direction compl_shows_dir = FORWARD;
 static int compl_pending = 0;               // > 1 for postponed CTRL-N
 static pos_T compl_startpos;
 static colnr_T compl_col = 0;               /* column where the text starts
                                              * that is being completed */
-static char_u     *compl_orig_text = NULL;  /* text as it was before
-                                             * completion started */
+static char_u *compl_orig_text = NULL;  /* text as it was before
+                                         * completion started */
 static int compl_cont_mode = 0;
 static expand_T compl_xp;
 
@@ -257,8 +257,8 @@ static colnr_T Insstart_textlen;        // length of line when insert started
 static colnr_T Insstart_blank_vcol;     // vcol for first inserted blank
 static bool update_Insstart_orig = true;  // set Insstart_orig to Insstart
 
-static char_u   *last_insert = NULL;    // the text of the previous insert,
-                                        // K_SPECIAL and CSI are escaped
+static char_u *last_insert = NULL;    // the text of the previous insert,
+                                      // K_SPECIAL and CSI are escaped
 static int last_insert_skip;      // nr of chars in front of previous insert
 static int new_insert_skip;       // nr of chars in front of current insert
 static int did_restart_edit;            // "restart_edit" when calling edit()
@@ -310,7 +310,7 @@ static void insert_enter(InsertState *s)
       s->ptr = (char_u *)"i";
     }
 
-    set_vim_var_string(VV_INSERTMODE, (char *) s->ptr, 1);
+    set_vim_var_string(VV_INSERTMODE, (char *)s->ptr, 1);
     set_vim_var_string(VV_CHAR, NULL, -1);
     ins_apply_autocmds(EVENT_INSERTENTER);
 
@@ -791,15 +791,22 @@ static int insert_execute(VimState *state, int key)
     }
   }
 
-  if (curwin->w_p_rl)
+  if (curwin->w_p_rl) {
     switch (s->c) {
-      case K_LEFT:    s->c = K_RIGHT; break;
-      case K_S_LEFT:  s->c = K_S_RIGHT; break;
-      case K_C_LEFT:  s->c = K_C_RIGHT; break;
-      case K_RIGHT:   s->c = K_LEFT; break;
-      case K_S_RIGHT: s->c = K_S_LEFT; break;
-      case K_C_RIGHT: s->c = K_C_LEFT; break;
+    case K_LEFT:
+      s->c = K_RIGHT; break;
+    case K_S_LEFT:
+      s->c = K_S_RIGHT; break;
+    case K_C_LEFT:
+      s->c = K_C_RIGHT; break;
+    case K_RIGHT:
+      s->c = K_LEFT; break;
+    case K_S_RIGHT:
+      s->c = K_S_LEFT; break;
+    case K_C_RIGHT:
+      s->c = K_C_LEFT; break;
     }
+  }
 
   // If 'keymodel' contains "startsel", may start selection.  If it
   // does, a CTRL-O and c will be stuffed, we need to get these
@@ -1288,8 +1295,9 @@ normalchar:
 
       // If the new value is already inserted or an empty string
       // then don't insert any character.
-      if (s->c == NUL)
+      if (s->c == NUL) {
         break;
+      }
     }
     // Try to perform smart-indenting.
     ins_try_si(s->c);
@@ -1309,8 +1317,8 @@ normalchar:
     // special character.  Let CTRL-] expand abbreviations without
     // inserting it.
     if (vim_iswordc(s->c)
-          // Add ABBR_OFF for characters above 0x100, this is
-          // what check_abbr() expects.
+        // Add ABBR_OFF for characters above 0x100, this is
+        // what check_abbr() expects.
         || (!echeck_abbr((s->c >= 0x100) ? (s->c + ABBR_OFF) : s->c)
             && s->c != Ctrl_RSB)) {
       insert_special(s->c, false, false);
@@ -1415,21 +1423,20 @@ bool edit(int cmdchar, bool startln, long count)
   return s->c == Ctrl_O;
 }
 
-/*
- * Redraw for Insert mode.
- * This is postponed until getting the next character to make '$' in the 'cpo'
- * option work correctly.
- * Only redraw when there are no characters available.  This speeds up
- * inserting sequences of characters (e.g., for CTRL-R).
- */
-static void ins_redraw(
-    bool ready                  // not busy with something
-)
+/// Redraw for Insert mode.
+/// This is postponed until getting the next character to make '$' in the 'cpo'
+/// option work correctly.
+/// Only redraw when there are no characters available.  This speeds up
+/// inserting sequences of characters (e.g., for CTRL-R).
+///
+/// @param ready  not busy with something
+static void ins_redraw(bool ready)
 {
   bool conceal_cursor_moved = false;
 
-  if (char_avail())
+  if (char_avail()) {
     return;
+  }
 
   // Trigger CursorMoved if the cursor moved.  Not when the popup menu is
   // visible, the command might delete it.
@@ -1655,8 +1662,8 @@ static void init_prompt(int cmdchar_todo)
 /// @return  true if the cursor is in the editable position of the prompt line.
 bool prompt_curpos_editable(void)
 {
-    return curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count
-        && curwin->w_cursor.col >= (int)STRLEN(prompt_text());
+  return curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count
+         && curwin->w_cursor.col >= (int)STRLEN(prompt_text());
 }
 
 /*
@@ -1685,8 +1692,9 @@ void display_dollar(colnr_T col)
 {
   colnr_T save_col;
 
-  if (!redrawing())
+  if (!redrawing()) {
     return;
+  }
 
   save_col = curwin->w_cursor.col;
   curwin->w_cursor.col = col;
@@ -1714,34 +1722,28 @@ static void undisplay_dollar(void)
   }
 }
 
-/*
- * Insert an indent (for <Tab> or CTRL-T) or delete an indent (for CTRL-D).
- * Keep the cursor on the same character.
- * type == INDENT_INC	increase indent (for CTRL-T or <Tab>)
- * type == INDENT_DEC	decrease indent (for CTRL-D)
- * type == INDENT_SET	set indent to "amount"
- * if round is TRUE, round the indent to 'shiftwidth' (only with _INC and _Dec).
- */
-void
-change_indent (
-    int type,
-    int amount,
-    int round,
-    int replaced,                   // replaced character, put on replace stack
-    int call_changed_bytes                 // call changed_bytes()
-)
+/// Insert an indent (for <Tab> or CTRL-T) or delete an indent (for CTRL-D).
+/// Keep the cursor on the same character.
+/// type == INDENT_INC   increase indent (for CTRL-T or <Tab>)
+/// type == INDENT_DEC   decrease indent (for CTRL-D)
+/// type == INDENT_SET   set indent to "amount"
+///
+/// @param round               if TRUE, round the indent to 'shiftwidth' (only with _INC and _Dec).
+/// @param replaced            replaced character, put on replace stack
+/// @param call_changed_bytes  call changed_bytes()
+void change_indent(int type, int amount, int round, int replaced, int call_changed_bytes)
 {
   int vcol;
   int last_vcol;
   int insstart_less;                    // reduction for Insstart.col
   int new_cursor_col;
   int i;
-  char_u      *ptr;
+  char_u *ptr;
   int save_p_list;
   int start_col;
   colnr_T vc;
   colnr_T orig_col = 0;                 // init for GCC
-  char_u      *new_line, *orig_line = NULL;     // init for GCC
+  char_u *new_line, *orig_line = NULL;     // init for GCC
 
   // VREPLACE mode needs to know what the line was like before changing
   if (State & VREPLACE_FLAG) {
@@ -1773,8 +1775,9 @@ change_indent (
    * If the cursor is in the indent, compute how many screen columns the
    * cursor is to the left of the first non-blank.
    */
-  if (new_cursor_col < 0)
+  if (new_cursor_col < 0) {
     vcol = get_indent() - vcol;
+  }
 
   if (new_cursor_col > 0) {         // can't fix replace stack
     start_col = -1;
@@ -1783,9 +1786,9 @@ change_indent (
   /*
    * Set the new indent.  The cursor will be put on the first non-blank.
    */
-  if (type == INDENT_SET)
+  if (type == INDENT_SET) {
     (void)set_indent(amount, call_changed_bytes ? SIN_CHANGED : 0);
-  else {
+  } else {
     int save_State = State;
 
     // Avoid being called recursively.
@@ -1811,12 +1814,13 @@ change_indent (
      * When changing the indent while the cursor is touching it, reset
      * Insstart_col to 0.
      */
-    if (new_cursor_col == 0)
+    if (new_cursor_col == 0) {
       insstart_less = MAXCOL;
+    }
     new_cursor_col += curwin->w_cursor.col;
-  } else if (!(State & INSERT))
+  } else if (!(State & INSERT)) {
     new_cursor_col = curwin->w_cursor.col;
-  else {
+  } else {
     /*
      * Compute the screen column where the cursor should be.
      */
@@ -1863,10 +1867,11 @@ change_indent (
 
   curwin->w_p_list = save_p_list;
 
-  if (new_cursor_col <= 0)
+  if (new_cursor_col <= 0) {
     curwin->w_cursor.col = 0;
-  else
+  } else {
     curwin->w_cursor.col = (colnr_T)new_cursor_col;
+  }
   curwin->w_set_curswant = TRUE;
   changed_cline_bef_curs();
 
@@ -1875,15 +1880,17 @@ change_indent (
    */
   if (State & INSERT) {
     if (curwin->w_cursor.lnum == Insstart.lnum && Insstart.col != 0) {
-      if ((int)Insstart.col <= insstart_less)
+      if ((int)Insstart.col <= insstart_less) {
         Insstart.col = 0;
-      else
+      } else {
         Insstart.col -= insstart_less;
+      }
     }
-    if ((int)ai_col <= insstart_less)
+    if ((int)ai_col <= insstart_less) {
       ai_col = 0;
-    else
+    } else {
       ai_col -= insstart_less;
+    }
   }
 
   /*
@@ -1975,10 +1982,11 @@ void backspace_until_column(int col)
 {
   while ((int)curwin->w_cursor.col > col) {
     curwin->w_cursor.col--;
-    if (State & REPLACE_FLAG)
+    if (State & REPLACE_FLAG) {
       replace_do_bs(col);
-    else if (!del_char_after_col(col))
+    } else if (!del_char_after_col(col)) {
       break;
+    }
   }
 }
 
@@ -2025,10 +2033,11 @@ static void ins_ctrl_x(void)
   if (ctrl_x_mode != CTRL_X_CMDLINE) {
     /* if the next ^X<> won't ADD nothing, then reset
      * compl_cont_status */
-    if (compl_cont_status & CONT_N_ADDS)
+    if (compl_cont_status & CONT_N_ADDS) {
       compl_cont_status |= CONT_INTRPT;
-    else
+    } else {
       compl_cont_status = 0;
+    }
     // We're not sure which CTRL-X mode it will be yet
     ctrl_x_mode = CTRL_X_NOT_DEFINED_YET;
     edit_submode = (char_u *)_(CTRL_X_MSG(ctrl_x_mode));
@@ -2172,8 +2181,8 @@ static bool ins_compl_accept_char(int c)
 /// the rest of the word to be in -- webb
 ///
 /// @param[in]  cont_s_ipos  next ^X<> will set initial_pos
-int ins_compl_add_infercase(char_u *str_arg, int len, bool icase, char_u *fname,
-                            Direction dir, bool cont_s_ipos)
+int ins_compl_add_infercase(char_u *str_arg, int len, bool icase, char_u *fname, Direction dir,
+                            bool cont_s_ipos)
   FUNC_ATTR_NONNULL_ARG(1)
 {
   char_u *str = str_arg;
@@ -2316,15 +2325,12 @@ int ins_compl_add_infercase(char_u *str_arg, int len, bool icase, char_u *fname,
 /// @return NOTDONE if the given string is already in the list of completions,
 ///         otherwise it is added to the list and  OK is returned. FAIL will be
 ///         returned in case of error.
-static int ins_compl_add(char_u *const str, int len,
-                         char_u *const fname,
-                         char_u *const *const cptext,
-                         const bool cptext_allocated,
-                         typval_T *user_data,
-                         const Direction cdir, int flags_arg, const bool adup)
+static int ins_compl_add(char_u *const str, int len, char_u *const fname,
+                         char_u *const *const cptext, const bool cptext_allocated,
+                         typval_T *user_data, const Direction cdir, int flags_arg, const bool adup)
   FUNC_ATTR_NONNULL_ARG(1)
 {
-  compl_T     *match;
+  compl_T *match;
   const Direction dir = (cdir == kDirectionNotSet ? compl_direction : cdir);
   int flags = flags_arg;
 
@@ -2420,9 +2426,9 @@ static int ins_compl_add(char_u *const str, int len,
   /*
    * Link the new match structure in the list of matches.
    */
-  if (compl_first_match == NULL)
+  if (compl_first_match == NULL) {
     match->cp_next = match->cp_prev = NULL;
-  else if (dir == FORWARD) {
+  } else if (dir == FORWARD) {
     match->cp_next = compl_curr_match->cp_next;
     match->cp_prev = compl_curr_match;
   } else {    // BACKWARD
@@ -2472,7 +2478,7 @@ static bool ins_compl_equal(compl_T *match, char_u *str, size_t len)
  */
 static void ins_compl_longest_match(compl_T *match)
 {
-  char_u      *p, *s;
+  char_u *p, *s;
   int c1, c2;
   int had_match;
 
@@ -2486,8 +2492,9 @@ static void ins_compl_longest_match(compl_T *match)
 
     /* When the match isn't there (to avoid matching itself) remove it
      * again after redrawing. */
-    if (!had_match)
+    if (!had_match) {
       ins_compl_delete();
+    }
     compl_used_match = false;
   } else {
     // Reduce the text if this match differs from compl_leader.
@@ -2516,8 +2523,9 @@ static void ins_compl_longest_match(compl_T *match)
 
       /* When the match isn't there (to avoid matching itself) remove it
        * again after redrawing. */
-      if (!had_match)
+      if (!had_match) {
         ins_compl_delete();
+      }
     }
 
     compl_used_match = false;
@@ -2601,8 +2609,9 @@ void set_completion(colnr_T startcol, list_T *list)
   ins_compl_free();
 
   compl_direction = FORWARD;
-  if (startcol > curwin->w_cursor.col)
+  if (startcol > curwin->w_cursor.col) {
     startcol = curwin->w_cursor.col;
+  }
   compl_col = startcol;
   compl_length = (int)curwin->w_cursor.col - (int)startcol;
   // compl_pattern doesn't need to be set
@@ -2725,8 +2734,8 @@ static void trigger_complete_changed_event(int cur)
 /// Also adjusts "compl_shown_match" to an entry that is actually displayed.
 void ins_compl_show_pum(void)
 {
-  compl_T     *compl;
-  compl_T     *shown_compl = NULL;
+  compl_T *compl;
+  compl_T *shown_compl = NULL;
   bool did_find_shown_match = false;
   bool shown_match_ok = false;
   int i;
@@ -2735,8 +2744,9 @@ void ins_compl_show_pum(void)
   int lead_len = 0;
   bool array_changed = false;
 
-  if (!pum_wanted() || !pum_enough_matches())
+  if (!pum_wanted() || !pum_enough_matches()) {
     return;
+  }
 
   // Dirty hard-coded hack: remove any matchparen highlighting.
   do_cmdline_cmd("if exists('g:loaded_matchparen')|3match none|endif");
@@ -2767,8 +2777,9 @@ void ins_compl_show_pum(void)
       }
       compl = compl->cp_next;
     } while (compl != NULL && compl != compl_first_match);
-    if (compl_match_arraysize == 0)
+    if (compl_match_arraysize == 0) {
       return;
+    }
 
     assert(compl_match_arraysize >= 0);
     compl_match_array = xcalloc(compl_match_arraysize, sizeof(pumitem_T));
@@ -2799,18 +2810,20 @@ void ins_compl_show_pum(void)
           cur = i;
         }
 
-        if (compl->cp_text[CPT_ABBR] != NULL)
+        if (compl->cp_text[CPT_ABBR] != NULL) {
           compl_match_array[i].pum_text =
             compl->cp_text[CPT_ABBR];
-        else
+        } else {
           compl_match_array[i].pum_text = compl->cp_str;
+        }
         compl_match_array[i].pum_kind = compl->cp_text[CPT_KIND];
         compl_match_array[i].pum_info = compl->cp_text[CPT_INFO];
-        if (compl->cp_text[CPT_MENU] != NULL)
+        if (compl->cp_text[CPT_MENU] != NULL) {
           compl_match_array[i++].pum_extra =
             compl->cp_text[CPT_MENU];
-        else
+        } else {
           compl_match_array[i++].pum_extra = compl->cp_fname;
+        }
       }
 
       if (compl == compl_shown_match) {
@@ -2867,23 +2880,18 @@ void ins_compl_show_pum(void)
 #define DICT_FIRST      (1)     // use just first element in "dict"
 #define DICT_EXACT      (2)     // "dict" is the exact name of a file
 
-/*
- * Add any identifiers that match the given pattern in the list of dictionary
- * files "dict_start" to the list of completions.
- */
-static void
-ins_compl_dictionaries (
-    char_u *dict_start,
-    char_u *pat,
-    int flags,                      // DICT_FIRST and/or DICT_EXACT
-    int thesaurus                  // Thesaurus completion
-)
-{
-  char_u      *dict = dict_start;
-  char_u      *ptr;
-  char_u      *buf;
+/// Add any identifiers that match the given pattern in the list of dictionary
+/// files "dict_start" to the list of completions.
+///
+/// @param flags      DICT_FIRST and/or DICT_EXACT
+/// @param thesaurus  Thesaurus completion
+static void ins_compl_dictionaries(char_u *dict_start, char_u *pat, int flags, int thesaurus)
+{
+  char_u *dict = dict_start;
+  char_u *ptr;
+  char_u *buf;
   regmatch_T regmatch;
-  char_u      **files;
+  char_u **files;
   int count;
   int save_p_scs;
   Direction dir = compl_direction;
@@ -2891,10 +2899,11 @@ ins_compl_dictionaries (
   if (*dict == NUL) {
     /* When 'dictionary' is empty and spell checking is enabled use
      * "spell". */
-    if (!thesaurus && curwin->w_p_spell)
+    if (!thesaurus && curwin->w_p_spell) {
       dict = (char_u *)"spell";
-    else
+    } else {
       return;
+    }
   }
 
   buf = xmalloc(LSIZE);
@@ -2902,8 +2911,9 @@ ins_compl_dictionaries (
 
   // If 'infercase' is set, don't use 'smartcase' here
   save_p_scs = p_scs;
-  if (curbuf->b_p_inf)
+  if (curbuf->b_p_inf) {
     p_scs = FALSE;
+  }
 
   /* When invoked to match whole lines for CTRL-X CTRL-L adjust the pattern
    * to only match at the start of a line.  Otherwise just match the
@@ -2919,8 +2929,9 @@ ins_compl_dictionaries (
     xfree(ptr);
   } else {
     regmatch.regprog = vim_regcomp(pat, p_magic ? RE_MAGIC : 0);
-    if (regmatch.regprog == NULL)
+    if (regmatch.regprog == NULL) {
       goto theend;
+    }
   }
 
   // ignore case depends on 'ignorecase', 'smartcase' and "pat"
@@ -2935,30 +2946,34 @@ ins_compl_dictionaries (
        * backticks (for security, the 'dict' option may have been set in
        * a modeline). */
       copy_option_part(&dict, buf, LSIZE, ",");
-      if (!thesaurus && STRCMP(buf, "spell") == 0)
+      if (!thesaurus && STRCMP(buf, "spell") == 0) {
         count = -1;
-      else if (vim_strchr(buf, '`') != NULL
-               || expand_wildcards(1, &buf, &count, &files,
-                   EW_FILE|EW_SILENT) != OK)
+      } else if (vim_strchr(buf, '`') != NULL
+                 || expand_wildcards(1, &buf, &count, &files,
+                                     EW_FILE|EW_SILENT) != OK) {
         count = 0;
+      }
     }
 
     if (count == -1) {
       /* Complete from active spelling.  Skip "\<" in the pattern, we
        * don't use it as a RE. */
-      if (pat[0] == '\\' && pat[1] == '<')
+      if (pat[0] == '\\' && pat[1] == '<') {
         ptr = pat + 2;
-      else
+      } else {
         ptr = pat;
+      }
       spell_dump_compl(ptr, regmatch.rm_ic, &dir, 0);
     } else if (count > 0) {  // avoid warning for using "files" uninit
       ins_compl_files(count, files, thesaurus, flags,
-          &regmatch, buf, &dir);
-      if (flags != DICT_EXACT)
+                      &regmatch, buf, &dir);
+      if (flags != DICT_EXACT) {
         FreeWild(count, files);
+      }
     }
-    if (flags != 0)
+    if (flags != 0) {
       break;
+    }
   }
 
 theend:
@@ -2967,14 +2982,13 @@ theend:
   xfree(buf);
 }
 
-static void ins_compl_files(int count, char_u **files, int thesaurus,
-                            int flags, regmatch_T *regmatch, char_u *buf,
-                            Direction *dir)
+static void ins_compl_files(int count, char_u **files, int thesaurus, int flags,
+                            regmatch_T *regmatch, char_u *buf, Direction *dir)
   FUNC_ATTR_NONNULL_ARG(2, 7)
 {
-  char_u      *ptr;
+  char_u *ptr;
   int i;
-  FILE        *fp;
+  FILE *fp;
   int add_r;
 
   for (i = 0; i < count && !got_int && !compl_interrupted; i++) {
@@ -3017,8 +3031,9 @@ static void ins_compl_files(int count, char_u **files, int thesaurus,
             /* Find start of the next word.  Skip white
              * space and punctuation. */
             ptr = find_word_start(ptr);
-            if (*ptr == NUL || *ptr == NL)
+            if (*ptr == NUL || *ptr == NL) {
               break;
+            }
             wstart = ptr;
 
             // Find end of the word.
@@ -3096,11 +3111,12 @@ char_u *find_word_end(char_u *ptr)
  */
 static char_u *find_line_end(char_u *ptr)
 {
-  char_u      *s;
+  char_u *s;
 
   s = ptr + STRLEN(ptr);
-  while (s > ptr && (s[-1] == CAR || s[-1] == NL))
+  while (s > ptr && (s[-1] == CAR || s[-1] == NL)) {
     --s;
+  }
   return s;
 }
 
@@ -3114,8 +3130,9 @@ static void ins_compl_free(void)
   XFREE_CLEAR(compl_pattern);
   XFREE_CLEAR(compl_leader);
 
-  if (compl_first_match == NULL)
+  if (compl_first_match == NULL) {
     return;
+  }
 
   ins_compl_del_pum();
   pum_clear();
@@ -3277,9 +3294,9 @@ void get_complete_info(list_T *what_list, dict_T *retdict)
           tv_dict_add_str(di, S_LEN("info"),
                           (char *)EMPTY_IF_NULL(match->cp_text[CPT_INFO]));
           if (match->cp_user_data.v_type == VAR_UNKNOWN) {
-              tv_dict_add_str(di, S_LEN("user_data"), "");
+            tv_dict_add_str(di, S_LEN("user_data"), "");
           } else {
-              tv_dict_add_tv(di, S_LEN("user_data"), &match->cp_user_data);
+            tv_dict_add_tv(di, S_LEN("user_data"), &match->cp_user_data);
           }
         }
         match = match->cp_next;
@@ -3319,8 +3336,8 @@ static char_u * ins_compl_mode(void)
  */
 static int ins_compl_bs(void)
 {
-  char_u      *line;
-  char_u      *p;
+  char_u *line;
+  char_u *p;
 
   line = get_cursor_line_ptr();
   p = line + curwin->w_cursor.col;
@@ -3340,8 +3357,9 @@ static int ins_compl_bs(void)
   /* Deleted more than what was used to find matches or didn't finish
    * finding all matches: need to look for matches all over again. */
   if (curwin->w_cursor.col <= compl_col + compl_length
-      || ins_compl_need_restart())
+      || ins_compl_need_restart()) {
     ins_compl_restart();
+  }
 
   xfree(compl_leader);
   compl_leader = vim_strnsave(line + compl_col, (int)(p - line) - compl_col);
@@ -3398,8 +3416,9 @@ static void ins_compl_new_leader(void)
 
   /* Don't let Enter select the original text when there is no popup menu.
    * Don't let Enter select when use user function and refresh_always is set */
-  if (compl_match_array == NULL || ins_compl_need_restart())
+  if (compl_match_array == NULL || ins_compl_need_restart()) {
     compl_enter_selects = FALSE;
+  }
 }
 
 /*
@@ -3410,8 +3429,9 @@ static int ins_compl_len(void)
 {
   int off = (int)curwin->w_cursor.col - (int)compl_col;
 
-  if (off < 0)
+  if (off < 0) {
     return 0;
+  }
   return off;
 }
 
@@ -3424,7 +3444,7 @@ static void ins_compl_addleader(int c)
   int cc;
 
   if (stop_arrow() == FAIL) {
-        return;
+    return;
   }
   if ((cc = utf_char2len(c)) > 1) {
     char_u buf[MB_MAXBYTES + 1];
@@ -3489,10 +3509,10 @@ static void ins_compl_set_original_text(char_u *str)
  */
 static void ins_compl_addfrommatch(void)
 {
-  char_u      *p;
+  char_u *p;
   int len = (int)curwin->w_cursor.col - (int)compl_col;
   int c;
-  compl_T     *cp;
+  compl_T *cp;
   assert(compl_shown_match != NULL);
   p = compl_shown_match->cp_str;
   if ((int)STRLEN(p) <= len) {   // the match is too short
@@ -3504,15 +3524,17 @@ static void ins_compl_addfrommatch(void)
            && cp != compl_first_match; cp = cp->cp_next) {
         if (compl_leader == NULL
             || ins_compl_equal(cp, compl_leader,
-                (int)STRLEN(compl_leader))) {
+                               (int)STRLEN(compl_leader))) {
           p = cp->cp_str;
           break;
         }
       }
-      if (p == NULL || (int)STRLEN(p) <= len)
+      if (p == NULL || (int)STRLEN(p) <= len) {
         return;
-    } else
+      }
+    } else {
       return;
+    }
   }
   p += len;
   c = PTR2CHAR(p);
@@ -3534,8 +3556,9 @@ static bool ins_compl_prep(int c)
   /* Forget any previous 'special' messages if this is actually
    * a ^X mode key - bar ^R, in which case we wait to see what it gives us.
    */
-  if (c != Ctrl_R && vim_is_ctrl_x_key(c))
+  if (c != Ctrl_R && vim_is_ctrl_x_key(c)) {
     edit_submode_extra = NULL;
+  }
 
   // Ignore end of Select mode mapping and mouse scroll buttons.
   if (c == K_SELECT || c == K_MOUSEDOWN || c == K_MOUSEUP
@@ -3560,10 +3583,11 @@ static bool ins_compl_prep(int c)
     case Ctrl_E:
     case Ctrl_Y:
       ctrl_x_mode = CTRL_X_SCROLL;
-      if (!(State & REPLACE_FLAG))
+      if (!(State & REPLACE_FLAG)) {
         edit_submode = (char_u *)_(" (insert) Scroll (^E/^Y)");
-      else
+      } else {
         edit_submode = (char_u *)_(" (replace) Scroll (^E/^Y)");
+      }
       edit_submode_pre = NULL;
       showmode();
       break;
@@ -3618,10 +3642,11 @@ static bool ins_compl_prep(int c)
        * ^X^F^X^P or ^P^X^X^P, see below)
        * nothing changes if interrupting mode 0, (eg, the flag
        * doesn't change when going to ADDING mode  -- Acevedo */
-      if (!(compl_cont_status & CONT_INTRPT))
+      if (!(compl_cont_status & CONT_INTRPT)) {
         compl_cont_status |= CONT_LOCAL;
-      else if (compl_cont_mode != 0)
+      } else if (compl_cont_mode != 0) {
         compl_cont_status &= ~CONT_LOCAL;
+      }
       FALLTHROUGH;
     default:
       /* If we have typed at least 2 ^X's... for modes != 0, we set
@@ -3635,10 +3660,11 @@ static bool ins_compl_prep(int c)
        * In mode 0 an extra ^X is needed since ^X^P goes to ADDING
        * mode  -- Acevedo */
       if (c == Ctrl_X) {
-        if (compl_cont_mode != 0)
+        if (compl_cont_mode != 0) {
           compl_cont_status = 0;
-        else
+        } else {
           compl_cont_mode = CTRL_X_NOT_DEFINED_YET;
+        }
       }
       ctrl_x_mode = CTRL_X_NORMAL;
       edit_submode = NULL;
@@ -3681,10 +3707,11 @@ static bool ins_compl_prep(int c)
          * When using the longest match, edited the match or used
          * CTRL-E then don't use the current match.
          */
-        if (compl_curr_match != NULL && compl_used_match && c != Ctrl_E)
+        if (compl_curr_match != NULL && compl_used_match && c != Ctrl_E) {
           ptr = compl_curr_match->cp_str;
-        else
+        } else {
           ptr = NULL;
+        }
         ins_compl_fixRedoBufForLeader(ptr);
       }
 
@@ -3766,16 +3793,18 @@ static bool ins_compl_prep(int c)
       /*
        * Indent now if a key was typed that is in 'cinkeys'.
        */
-      if (want_cindent && in_cinkeys(KEY_COMPLETE, ' ', inindent(0)))
+      if (want_cindent && in_cinkeys(KEY_COMPLETE, ' ', inindent(0))) {
         do_c_expr_indent();
+      }
       // Trigger the CompleteDone event to give scripts a chance to act
       // upon the end of completion.
       ins_apply_autocmds(EVENT_COMPLETEDONE);
     }
-  } else if (ctrl_x_mode == CTRL_X_LOCAL_MSG)
+  } else if (ctrl_x_mode == CTRL_X_LOCAL_MSG) {
     /* Trigger the CompleteDone event to give scripts a chance to act
      * upon the (possibly failed) completion. */
     ins_apply_autocmds(EVENT_COMPLETEDONE);
+  }
 
   /* reset continue_* if we left expansion-mode, if we stay they'll be
    * (re)set properly in ins_complete() */
@@ -3795,8 +3824,8 @@ static bool ins_compl_prep(int c)
 static void ins_compl_fixRedoBufForLeader(char_u *ptr_arg)
 {
   int len;
-  char_u  *p;
-  char_u  *ptr = ptr_arg;
+  char_u *p;
+  char_u *ptr = ptr_arg;
 
   if (ptr == NULL) {
     if (compl_leader != NULL) {
@@ -3823,7 +3852,7 @@ static void ins_compl_fixRedoBufForLeader(char_u *ptr_arg)
 /*
  * Loops through the list of windows, loaded-buffers or non-loaded-buffers
  * (depending on flag) starting from buf and looking for a non-scanned
- * buffer (other than curbuf).	curbuf is special, if it is called with
+ * buffer (other than curbuf).  curbuf is special, if it is called with
  * buf=curbuf then it has to be the first call for a given flag/expansion.
  *
  * Returns the buffer to scan, if any, otherwise returns curbuf -- Acevedo
@@ -3838,10 +3867,11 @@ static buf_T *ins_compl_next_buf(buf_T *buf, int flag)
     }
     assert(wp);
     while ((wp = (wp->w_next != NULL ? wp->w_next : firstwin)) != curwin
-           && wp->w_buffer->b_scanned)
+           && wp->w_buffer->b_scanned) {
       ;
+    }
     buf = wp->w_buffer;
-  } else
+  } else {
     /* 'b' (just loaded buffers), 'u' (just non-loaded buffers) or 'U'
      * (unlisted buffers)
      * When completing whole lines skip unloaded buffers. */
@@ -3850,19 +3880,19 @@ static buf_T *