refactor: format with uncrustify #15726

10 files changed, 2203 insertions, 2109 deletions

diff --git a/src/nvim/debugger.c b/src/nvim/debugger.c
index 73665009ff..a5dd4cd485 100644
--- a/src/nvim/debugger.c
+++ b/src/nvim/debugger.c
@@ -60,9 +60,9 @@ void do_debug(char_u *cmd)
   int save_ignore_script = 0;
   int save_ex_normal_busy;
   int n;
-  char_u      *cmdline = NULL;
-  char_u      *p;
-  char        *tail = NULL;
+  char_u *cmdline = NULL;
+  char_u *p;
+  char *tail = NULL;
   static int last_cmd = 0;
 #define CMD_CONT        1
 #define CMD_NEXT        2
@@ -145,13 +145,16 @@ void do_debug(char_u *cmd)
       p = skipwhite(cmdline);
       if (*p != NUL) {
         switch (*p) {
-        case 'c': last_cmd = CMD_CONT;
+        case 'c':
+          last_cmd = CMD_CONT;
           tail = "ont";
           break;
-        case 'n': last_cmd = CMD_NEXT;
+        case 'n':
+          last_cmd = CMD_NEXT;
           tail = "ext";
           break;
-        case 's': last_cmd = CMD_STEP;
+        case 's':
+          last_cmd = CMD_STEP;
           tail = "tep";
           break;
         case 'f':
@@ -164,10 +167,12 @@ void do_debug(char_u *cmd)
             tail = "inish";
           }
           break;
-        case 'q': last_cmd = CMD_QUIT;
+        case 'q':
+          last_cmd = CMD_QUIT;
           tail = "uit";
           break;
-        case 'i': last_cmd = CMD_INTERRUPT;
+        case 'i':
+          last_cmd = CMD_INTERRUPT;
           tail = "nterrupt";
           break;
         case 'b':
@@ -190,7 +195,8 @@ void do_debug(char_u *cmd)
           last_cmd = CMD_DOWN;
           tail = "own";
           break;
-        default: last_cmd = 0;
+        default:
+          last_cmd = 0;
         }
         if (last_cmd != 0) {
           // Check that the tail matches.
@@ -366,7 +372,7 @@ void ex_debug(exarg_T *eap)
   debug_break_level = debug_break_level_save;
 }
 
-static char_u   *debug_breakpoint_name = NULL;
+static char_u *debug_breakpoint_name = NULL;
 static linenr_T debug_breakpoint_lnum;
 
 /// When debugging or a breakpoint is set on a skipped command, no debug prompt
@@ -375,7 +381,7 @@ static linenr_T debug_breakpoint_lnum;
 /// a skipped command decides itself that a debug prompt should be displayed, it
 /// can do so by calling dbg_check_skipped().
 static int debug_skipped;
-static char_u   *debug_skipped_name;
+static char_u *debug_skipped_name;
 
 /// Go to debug mode when a breakpoint was encountered or "ex_nesting_level" is
 /// at or below the break level.  But only when the line is actually
@@ -384,7 +390,7 @@ static char_u   *debug_skipped_name;
 /// Called from do_one_cmd() before executing a command.
 void dbg_check_breakpoint(exarg_T *eap)
 {
-  char_u      *p;
+  char_u *p;
 
   debug_skipped = false;
   if (debug_breakpoint_name != NULL) {
@@ -474,8 +480,8 @@ static typval_T *eval_expr_no_emsg(struct debuggy *const bp)
 /// @param gap  either &dbg_breakp or &prof_ga
 static int dbg_parsearg(char_u *arg, garray_T *gap)
 {
-  char_u      *p = arg;
-  char_u      *q;
+  char_u *p = arg;
+  char_u *q;
   struct debuggy *bp;
   bool here = false;
 
@@ -559,7 +565,7 @@ static int dbg_parsearg(char_u *arg, garray_T *gap)
 void ex_breakadd(exarg_T *eap)
 {
   struct debuggy *bp;
-  garray_T    *gap;
+  garray_T *gap;
 
   gap = &dbg_breakp;
   if (eap->cmdidx == CMD_profile) {
@@ -614,7 +620,7 @@ void ex_breakdel(exarg_T *eap)
   int todel = -1;
   bool del_all = false;
   linenr_T best_lnum = 0;
-  garray_T    *gap;
+  garray_T *gap;
 
   gap = &dbg_breakp;
   if (eap->cmdidx == CMD_profdel) {
@@ -712,12 +718,10 @@ void ex_breaklist(exarg_T *eap)
 
 /// Find a breakpoint for a function or sourced file.
 /// Returns line number at which to break; zero when no matching breakpoint.
-linenr_T
-dbg_find_breakpoint(
-    bool file,             // true for a file, false for a function
-    char_u *fname,         // file or function name
-    linenr_T after         // after this line number
-)
+linenr_T dbg_find_breakpoint(bool file,             // true for a file, false for a function
+                             char_u *fname,         // file or function name
+                             linenr_T after         // after this line number
+                             )
 {
   return debuggy_find(file, fname, after, &dbg_breakp, NULL);
 }
@@ -734,18 +738,16 @@ bool has_profiling(bool file, char_u *fname, bool *fp)
 }
 
 /// Common code for dbg_find_breakpoint() and has_profiling().
-static linenr_T
-debuggy_find(
-    bool file,            // true for a file, false for a function
-    char_u *fname,        // file or function name
-    linenr_T after,       // after this line number
-    garray_T *gap,        // either &dbg_breakp or &prof_ga
-    bool *fp              // if not NULL: return forceit
-)
+static linenr_T debuggy_find(bool file,            // true for a file, false for a function
+                             char_u *fname,        // file or function name
+                             linenr_T after,       // after this line number
+                             garray_T *gap,        // either &dbg_breakp or &prof_ga
+                             bool *fp              // if not NULL: return forceit
+                             )
 {
   struct debuggy *bp;
   linenr_T lnum = 0;
-  char_u      *name = fname;
+  char_u *name = fname;
   int prev_got_int;
 
   // Return quickly when there are no breakpoints.
diff --git a/src/nvim/decoration.c b/src/nvim/decoration.c
index 5168ed6d0f..0f21b47261 100644
--- a/src/nvim/decoration.c
+++ b/src/nvim/decoration.c
@@ -1,13 +1,13 @@
 // This is an open source non-commercial project. Dear PVS-Studio, please check
 // it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
 
-#include "nvim/vim.h"
-#include "nvim/lua/executor.h"
-#include "nvim/extmark.h"
 #include "nvim/decoration.h"
+#include "nvim/extmark.h"
+#include "nvim/highlight.h"
+#include "nvim/lua/executor.h"
 #include "nvim/screen.h"
 #include "nvim/syntax.h"
-#include "nvim/highlight.h"
+#include "nvim/vim.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "decoration.c.generated.h"
@@ -28,11 +28,7 @@ static PMap(uint64_t) hl_decors;
 /// @param pos_start Cursor position to start the highlighting at
 /// @param pos_end Cursor position to end the highlighting at
 /// @param offset Move the whole highlighting this many columns to the right
-void bufhl_add_hl_pos_offset(buf_T *buf,
-                             int src_id,
-                             int hl_id,
-                             lpos_T pos_start,
-                             lpos_T pos_end,
+void bufhl_add_hl_pos_offset(buf_T *buf, int src_id, int hl_id, lpos_T pos_start, lpos_T pos_end,
                              colnr_T offset)
 {
   colnr_T hl_start = 0;
@@ -172,7 +168,7 @@ bool decor_redraw_start(buf_T *buf, int top_row, DecorState *state)
     ExtmarkItem *item = map_ref(uint64_t, ExtmarkItem)(buf->b_extmark_index,
                                                        start_id, false);
     if (!item || !item->decor) {
-    // TODO(bfredl): dedicated flag for being a decoration?
+      // TODO(bfredl): dedicated flag for being a decoration?
       goto next_mark;
     }
     Decoration *decor = item->decor;
@@ -217,14 +213,14 @@ bool decor_redraw_line(buf_T *buf, int row, DecorState *state)
   return true;  // TODO(bfredl): be more precise
 }
 
-static void decor_add(DecorState *state, int start_row, int start_col,
-                      int end_row, int end_col, Decoration *decor, bool owned)
+static void decor_add(DecorState *state, int start_row, int start_col, int end_row, int end_col,
+                      Decoration *decor, bool owned)
 {
   int attr_id = decor->hl_id > 0 ? syn_id2attr(decor->hl_id) : 0;
 
   DecorRange range = { start_row, start_col, end_row, end_col,
                        *decor, attr_id,
-                    kv_size(decor->virt_text) && owned, -1 };
+                       kv_size(decor->virt_text) && owned, -1 };
 
   kv_pushp(state->active);
   size_t index;
@@ -238,8 +234,7 @@ static void decor_add(DecorState *state, int start_row, int start_col,
   kv_A(state->active, index) = range;
 }
 
-int decor_redraw_col(buf_T *buf, int col, int win_col, bool hidden,
-                     DecorState *state)
+int decor_redraw_col(buf_T *buf, int col, int win_col, bool hidden, DecorState *state)
 {
   if (col <= state->col_until) {
     return state->current;
@@ -257,7 +252,7 @@ int decor_redraw_col(buf_T *buf, int col, int win_col, bool hidden,
     }
 
     if ((mark.id&MARKTREE_END_FLAG)) {
-       // TODO(bfredl): check decoration flag
+      // TODO(bfredl): check decoration flag
       goto next_mark;
     }
     mtpos_t endpos = marktree_lookup(buf->b_marktree,
@@ -266,7 +261,7 @@ int decor_redraw_col(buf_T *buf, int col, int win_col, bool hidden,
     ExtmarkItem *item = map_ref(uint64_t, ExtmarkItem)(buf->b_extmark_index,
                                                        mark.id, false);
     if (!item || !item->decor) {
-    // TODO(bfredl): dedicated flag for being a decoration?
+      // TODO(bfredl): dedicated flag for being a decoration?
       goto next_mark;
     }
     Decoration *decor = item->decor;
@@ -355,8 +350,7 @@ bool decor_redraw_eol(buf_T *buf, DecorState *state, int *eol_attr, int eol_col)
   return has_virttext;
 }
 
-void decor_add_ephemeral(int start_row, int start_col, int end_row, int end_col,
-                         Decoration *decor)
+void decor_add_ephemeral(int start_row, int start_col, int end_row, int end_col, Decoration *decor)
 {
   if (end_row == -1) {
     end_row = start_row;
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index fd5b2c6599..62af6a6393 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -13,14 +13,12 @@
 #include <inttypes.h>
 #include <stdbool.h>
 
-#include "nvim/vim.h"
-#include "xdiff/xdiff.h"
 #include "nvim/ascii.h"
-#include "nvim/diff.h"
 #include "nvim/buffer.h"
 #include "nvim/change.h"
 #include "nvim/charset.h"
 #include "nvim/cursor.h"
+#include "nvim/diff.h"
 #include "nvim/eval.h"
 #include "nvim/ex_cmds.h"
 #include "nvim/ex_docmd.h"
@@ -29,19 +27,21 @@
 #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/memory.h"
 #include "nvim/move.h"
 #include "nvim/normal.h"
 #include "nvim/option.h"
+#include "nvim/os/os.h"
+#include "nvim/os/shell.h"
 #include "nvim/path.h"
 #include "nvim/screen.h"
 #include "nvim/strings.h"
 #include "nvim/undo.h"
+#include "nvim/vim.h"
 #include "nvim/window.h"
-#include "nvim/os/os.h"
-#include "nvim/os/shell.h"
+#include "xdiff/xdiff.h"
 
 static int diff_busy = false;         // using diff structs, don't change them
 static bool diff_need_update = false;  // ex_diffupdate needs to be called
@@ -72,22 +72,22 @@ static TriState diff_a_works = kNone;
 
 // used for diff input
 typedef struct {
-    char_u   *din_fname;   // used for external diff
-    mmfile_t  din_mmfile;  // used for internal diff
+  char_u *din_fname;   // used for external diff
+  mmfile_t  din_mmfile;  // used for internal diff
 } diffin_T;
 
 // used for diff result
 typedef struct {
-    char_u   *dout_fname;  // used for external diff
-    garray_T  dout_ga;     // used for internal diff
+  char_u *dout_fname;  // used for external diff
+  garray_T  dout_ga;     // used for internal diff
 } diffout_T;
 
 // two diff inputs and one result
 typedef struct {
-    diffin_T    dio_orig;      // original file input
-    diffin_T    dio_new;       // new file input
-    diffout_T   dio_diff;      // diff result
-    int         dio_internal;  // using internal diff
+  diffin_T    dio_orig;      // original file input
+  diffin_T    dio_new;       // new file input
+  diffout_T   dio_diff;      // diff result
+  int         dio_internal;  // using internal diff
 } diffio_T;
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
@@ -119,7 +119,6 @@ void diff_buf_delete(buf_T *buf)
 /// @param win
 void diff_buf_adjust(win_T *win)
 {
-
   if (!win->w_p_diff) {
     // When there is no window showing a diff for this buffer, remove
     // it from the diffs.
@@ -242,8 +241,7 @@ void diff_invalidate(buf_T *buf)
 /// @param line2
 /// @param amount
 /// @param amount_after
-void diff_mark_adjust(linenr_T line1, linenr_T line2, long amount,
-                      long amount_after)
+void diff_mark_adjust(linenr_T line1, linenr_T line2, long amount, long amount_after)
 {
   // Handle all tab pages that use the current buffer in a diff.
   FOR_ALL_TABS(tp) {
@@ -267,8 +265,8 @@ void diff_mark_adjust(linenr_T line1, linenr_T line2, long amount,
 /// @param line2
 /// @param amount
 /// @amount_after
-static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1,
-                                linenr_T line2, long amount, long amount_after)
+static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1, linenr_T line2, long amount,
+                                long amount_after)
 {
   if (diff_internal()) {
     // Will update diffs before redrawing.  Set _invalid to update the
@@ -299,7 +297,7 @@ static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1,
   diff_T *dp = tp->tp_first_diff;
 
   linenr_T last;
-  linenr_T lnum_deleted = line1; // lnum of remaining deletion
+  linenr_T lnum_deleted = line1;  // lnum of remaining deletion
   int n;
   int off;
   for (;;) {
@@ -323,8 +321,8 @@ static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1,
             dnext->df_lnum[i] = line1;
           } else {
             dnext->df_lnum[i] = line1
-                + (dprev->df_lnum[i] + dprev->df_count[i])
-                - (dprev->df_lnum[idx] + dprev->df_count[idx]);
+                                + (dprev->df_lnum[i] + dprev->df_count[i])
+                                - (dprev->df_lnum[idx] + dprev->df_count[idx]);
           }
           dnext->df_count[i] = deleted;
         }
@@ -509,7 +507,7 @@ static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1,
 /// @param dp
 ///
 /// @return The new diff block.
-static diff_T* diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp)
+static diff_T * diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp)
 {
   diff_T *dnew = xmalloc(sizeof(*dnew));
 
@@ -705,9 +703,9 @@ static void clear_diffout(diffout_T *dout)
 static int diff_write_buffer(buf_T *buf, diffin_T *din)
 {
   linenr_T   lnum;
-  char_u    *s;
+  char_u *s;
   long       len = 0;
-  char_u    *ptr;
+  char_u *ptr;
 
   // xdiff requires one big block of memory with all the text.
   for (lnum = 1; lnum <= buf->b_ml.ml_line_count; lnum++) {
@@ -789,9 +787,7 @@ static int diff_write(buf_T *buf, diffin_T *din)
 /// @param dio
 /// @param idx_orig
 /// @param eap   can be NULL
-static void diff_try_update(diffio_T    *dio,
-                            int     idx_orig,
-                            exarg_T     *eap)
+static void diff_try_update(diffio_T *dio, int     idx_orig, exarg_T *eap)
 {
   buf_T *buf;
   int    idx_new;
@@ -1090,9 +1086,9 @@ static int diff_file_internal(diffio_T *diffio)
 /// @return OK or FAIL
 static int diff_file(diffio_T *dio)
 {
-  char  *tmp_orig = (char *)dio->dio_orig.din_fname;
-  char  *tmp_new = (char *)dio->dio_new.din_fname;
-  char  *tmp_diff = (char *)dio->dio_diff.dout_fname;
+  char *tmp_orig = (char *)dio->dio_orig.din_fname;
+  char *tmp_new = (char *)dio->dio_new.din_fname;
+  char *tmp_diff = (char *)dio->dio_diff.dout_fname;
   if (*p_dex != NUL) {
     // Use 'diffexpr' to generate the diff file.
     eval_diff(tmp_orig, tmp_new, tmp_diff);
@@ -1123,9 +1119,9 @@ static int diff_file(diffio_T *dio)
                  (diff_flags & DIFF_IBLANK) ? "-B " : "",
                  (diff_flags & DIFF_ICASE) ? "-i " : "",
                  tmp_orig, tmp_new);
-    append_redir(cmd, len, (char *) p_srr, tmp_diff);
+    append_redir(cmd, len, (char *)p_srr, tmp_diff);
     block_autocmds();  // Avoid ShellCmdPost stuff
-    (void)call_shell((char_u *) cmd,
+    (void)call_shell((char_u *)cmd,
                      kShellOptFilter | kShellOptSilent | kShellOptDoOut,
                      NULL);
     unblock_autocmds();
@@ -1171,8 +1167,8 @@ void ex_diffpatch(exarg_T *eap)
 #ifdef UNIX
   // Get the absolute path of the patchfile, changing directory below.
   fullname = FullName_save((char *)eap->arg, false);
-  esc_name = vim_strsave_shellescape(
-      (fullname != NULL ? (char_u *)fullname : eap->arg), true, true);
+  esc_name =
+    vim_strsave_shellescape((fullname != NULL ? (char_u *)fullname : eap->arg), true, true);
 #else
   esc_name = vim_strsave_shellescape(eap->arg, true, true);
 #endif
@@ -1324,8 +1320,8 @@ void ex_diffsplit(exarg_T *eap)
 
         if (bufref_valid(&old_curbuf)) {
           // Move the cursor position to that of the old window.
-          curwin->w_cursor.lnum = diff_get_corresponding_line(
-              old_curbuf.br_buf, old_curwin->w_cursor.lnum);
+          curwin->w_cursor.lnum = diff_get_corresponding_line(old_curbuf.br_buf,
+                                                              old_curwin->w_cursor.lnum);
         }
       }
       // Now that lines are folded scroll to show the cursor at the same
@@ -1344,15 +1340,15 @@ void ex_diffthis(exarg_T *eap)
 
 static void set_diff_option(win_T *wp, int value)
 {
-    win_T *old_curwin = curwin;
-
-    curwin = wp;
-    curbuf = curwin->w_buffer;
-    curbuf->b_ro_locked++;
-    set_option_value("diff", (long)value, NULL, OPT_LOCAL);
-    curbuf->b_ro_locked--;
-    curwin = old_curwin;
-    curbuf = curwin->w_buffer;
+  win_T *old_curwin = curwin;
+
+  curwin = wp;
+  curbuf = curwin->w_buffer;
+  curbuf->b_ro_locked++;
+  set_option_value("diff", (long)value, NULL, OPT_LOCAL);
+  curbuf->b_ro_locked--;
+  curwin = old_curwin;
+  curbuf = curwin->w_buffer;
 }
 
 
@@ -1724,8 +1720,7 @@ static void diff_read(int idx_orig, int idx_new, diffout_T *dout)
 /// @param dp
 /// @param idx_orig
 /// @param idx_new
-static void diff_copy_entry(diff_T *dprev, diff_T *dp, int idx_orig,
-                            int idx_new)
+static void diff_copy_entry(diff_T *dprev, diff_T *dp, int idx_orig, int idx_new)
 {
   long off;
 
@@ -1769,7 +1764,7 @@ void diff_clear(tabpage_T *tp)
 /// @return diff status.
 int diff_check(win_T *wp, linenr_T lnum)
 {
-  int idx; // index in tp_diffbuf[] for this buffer
+  int idx;  // index in tp_diffbuf[] for this buffer
   diff_T *dp;
   int maxcount;
   int i;
@@ -1912,8 +1907,7 @@ static bool diff_equal_entry(diff_T *dp, int idx1, int idx2)
 
 // Compare the characters at "p1" and "p2".  If they are equal (possibly
 // ignoring case) return true and set "len" to the number of bytes.
-static bool diff_equal_char(const char_u *const p1, const char_u *const p2,
-                            int *const len)
+static bool diff_equal_char(const char_u *const p1, const char_u *const p2, int *const len)
 {
   const int l = utfc_ptr2len(p1);
 
@@ -2537,7 +2531,7 @@ void ex_diffgetput(exarg_T *eap)
       if ((curtab->tp_diffbuf[i] != curbuf)
           && (curtab->tp_diffbuf[i] != NULL)
           && ((eap->cmdidx != CMD_diffput)
-            || MODIFIABLE(curtab->tp_diffbuf[i]))) {
+              || MODIFIABLE(curtab->tp_diffbuf[i]))) {
         EMSG(_("E101: More than two buffers in diff mode, don't know "
                "which one to use"));
         return;
@@ -2958,7 +2952,7 @@ static linenr_T diff_get_corresponding_line_int(buf_T *buf1, linenr_T lnum1)
       return curwin->w_cursor.lnum;
     }
     baseline = (dp->df_lnum[idx1] + dp->df_count[idx1])
-                - (dp->df_lnum[idx2] + dp->df_count[idx2]);
+               - (dp->df_lnum[idx2] + dp->df_count[idx2]);
   }
 
   // If we get here then the cursor is after the last diff
@@ -3035,11 +3029,8 @@ linenr_T diff_lnum_win(linenr_T lnum, win_T *wp)
 /// Handle an ED style diff line.
 /// Return FAIL if the line does not contain diff info.
 ///
-static int parse_diff_ed(char_u     *line,
-                         linenr_T    *lnum_orig,
-                         long       *count_orig,
-                         linenr_T    *lnum_new,
-                         long       *count_new)
+static int parse_diff_ed(char_u *line, linenr_T *lnum_orig, long *count_orig, linenr_T *lnum_new,
+                         long *count_new)
 {
   char_u *p;
   long    f1, l1, f2, l2;
@@ -3093,11 +3084,8 @@ static int parse_diff_ed(char_u     *line,
 /// Parses unified diff with zero(!) context lines.
 /// Return FAIL if there is no diff information in "line".
 ///
-static int parse_diff_unified(char_u        *line,
-                              linenr_T    *lnum_orig,
-                              long      *count_orig,
-                              linenr_T    *lnum_new,
-                              long      *count_new)
+static int parse_diff_unified(char_u *line, linenr_T *lnum_orig, long *count_orig,
+                              linenr_T *lnum_new, long *count_new)
 {
   char_u *p;
   long    oldline, oldcount, newline, newcount;
@@ -3153,7 +3141,7 @@ static int parse_diff_unified(char_u        *line,
 static int xdiff_out(void *priv, mmbuffer_t *mb, int nbuf)
 {
   diffout_T *dout = (diffout_T *)priv;
-  char_u    *p;
+  char_u *p;
 
   // The header line always comes by itself, text lines in at least two
   // parts.  We drop the text part.
diff --git a/src/nvim/digraph.c b/src/nvim/digraph.c
index 07e484c178..abca7cb905 100644
--- a/src/nvim/digraph.c
+++ b/src/nvim/digraph.c
@@ -6,26 +6,26 @@
 /// code for digraphs
 
 #include <assert.h>
-#include <stdbool.h>
 #include <inttypes.h>
+#include <stdbool.h>
 
-#include "nvim/vim.h"
 #include "nvim/ascii.h"
-#include "nvim/digraph.h"
 #include "nvim/charset.h"
+#include "nvim/digraph.h"
 #include "nvim/ex_cmds2.h"
 #include "nvim/ex_docmd.h"
 #include "nvim/ex_getln.h"
+#include "nvim/garray.h"
 #include "nvim/getchar.h"
-#include "nvim/misc1.h"
 #include "nvim/mbyte.h"
-#include "nvim/message.h"
 #include "nvim/memory.h"
-#include "nvim/garray.h"
+#include "nvim/message.h"
+#include "nvim/misc1.h"
 #include "nvim/normal.h"
+#include "nvim/os/input.h"
 #include "nvim/screen.h"
 #include "nvim/strings.h"
-#include "nvim/os/input.h"
+#include "nvim/vim.h"
 
 typedef int result_T;
 
@@ -40,7 +40,7 @@ typedef struct digraph {
 # include "digraph.c.generated.h"
 #endif
 // digraphs added by the user
-static garray_T user_digraphs = {0, 0, (int)sizeof(digr_T), 10, NULL};
+static garray_T user_digraphs = { 0, 0, (int)sizeof(digr_T), 10, NULL };
 
 /// Note: Characters marked with XX are not included literally, because some
 /// compilers cannot handle them (Amiga SAS/C is the most picky one).
@@ -49,7 +49,7 @@ static digr_T digraphdefault[] =
 // digraphs for Unicode from RFC1345
 // (also work for ISO-8859-1 aka latin1)
 {
-  { 'N', 'U', 0x0a }, // LF for NUL
+  { 'N', 'U', 0x0a },  // LF for NUL
   { 'S', 'H', 0x01 },
   { 'S', 'X', 0x02 },
   { 'E', 'X', 0x03 },
@@ -1452,12 +1452,12 @@ static digr_T digraphdefault[] =
 /// @return The digraph.
 int do_digraph(int c)
 {
-  static int backspaced; // character before K_BS
+  static int backspaced;  // character before K_BS
   static int lastchar;   // last typed character
 
   if (c == -1) {         // init values
     backspaced = -1;
-  } else if (p_dg)   {
+  } else if (p_dg) {
     if (backspaced >= 0) {
       c = getdigraph(backspaced, c, false);
     }
@@ -1557,7 +1557,7 @@ static int getexactdigraph(int char1, int char2, bool meta_char)
   // Search user digraphs first.
   digr_T *dp = (digr_T *)user_digraphs.ga_data;
   for (int i = 0; i < user_digraphs.ga_len; ++i) {
-    if (((int) dp->char1 == char1) && ((int) dp->char2 == char2)) {
+    if (((int)dp->char1 == char1) && ((int)dp->char2 == char2)) {
       retval = dp->result;
       break;
     }
@@ -1569,7 +1569,7 @@ static int getexactdigraph(int char1, int char2, bool meta_char)
     dp = digraphdefault;
 
     for (int i = 0; dp->char1 != 0; ++i) {
-      if (((int) dp->char1 == char1) && ((int) dp->char2 == char2)) {
+      if (((int)dp->char1 == char1) && ((int)dp->char2 == char2)) {
         retval = dp->result;
         break;
       }
@@ -1821,7 +1821,7 @@ typedef struct {
 /// @return NULL if OK, an error message for failure.  This only needs to be
 ///         used when setting the option, not later when the value has already
 ///         been checked.
-char_u* keymap_init(void)
+char_u * keymap_init(void)
 {
   curbuf->b_kmap_state &= ~KEYMAP_INIT;
 
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;