refactor(fold): style #19175

* refactor(fold): update comment formatting
* refactor(fold): use post-increment/decrement
* refactor(fold): reduce scope of local variables
* refactor(fold): use booleans

4 files changed, 234 insertions, 314 deletions

diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 8fe62ae424..763aca62ef 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -2341,7 +2341,7 @@ static char *do_one_cmd(char **cmdlinep, int flags, cstack_T *cstack, LineGetter
       do_return(&ea, TRUE, FALSE, NULL);
     }
   }
-  need_rethrow = check_cstack = FALSE;
+  need_rethrow = check_cstack = false;
 
 doend:
   // can happen with zero line number
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index 3c3aaa1031..8f26e03a94 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -3,9 +3,7 @@
 
 // vim: set fdm=marker fdl=1 fdc=3
 
-/*
- * fold.c: code for folding
- */
+// fold.c: code for folding
 
 #include <inttypes.h>
 #include <string.h>
@@ -41,12 +39,12 @@
 
 // local declarations. {{{1
 // typedef fold_T {{{2
-/*
- * The toplevel folds for each window are stored in the w_folds growarray.
- * Each toplevel fold can contain an array of second level folds in the
- * fd_nested growarray.
- * The info stored in both growarrays is the same: An array of fold_T.
- */
+
+// The toplevel folds for each window are stored in the w_folds growarray.
+// Each toplevel fold can contain an array of second level folds in the
+// fd_nested growarray.
+// The info stored in both growarrays is the same: An array of fold_T.
+
 typedef struct {
   linenr_T fd_top;              // first line of fold; for nested fold
                                 // relative to parent
@@ -93,20 +91,16 @@ typedef void (*LevelGetter)(fline_T *);
 #endif
 static char *e_nofold = N_("E490: No fold found");
 
-/*
- * While updating the folds lines between invalid_top and invalid_bot have an
- * undefined fold level.  Only used for the window currently being updated.
- */
+// While updating the folds lines between invalid_top and invalid_bot have an
+// undefined fold level.  Only used for the window currently being updated.
 static linenr_T invalid_top = (linenr_T)0;
 static linenr_T invalid_bot = (linenr_T)0;
 
-/*
- * When using 'foldexpr' we sometimes get the level of the next line, which
- * calls foldlevel() to get the level of the current line, which hasn't been
- * stored yet.  To get around this chicken-egg problem the level of the
- * previous line is stored here when available.  prev_lnum is zero when the
- * level is not available.
- */
+// When using 'foldexpr' we sometimes get the level of the next line, which
+// calls foldlevel() to get the level of the current line, which hasn't been
+// stored yet.  To get around this chicken-egg problem the level of the
+// previous line is stored here when available.  prev_lnum is zero when the
+// level is not available.
 static linenr_T prev_lnum = 0;
 static int prev_lnum_lvl = -1;
 
@@ -130,7 +124,7 @@ void copyFoldingState(win_T *wp_from, win_T *wp_to)
 }
 
 // hasAnyFolding() {{{2
-/// @return  TRUE if there may be folded lines in the current window.
+/// @return  true if there may be folded lines in the current window.
 int hasAnyFolding(win_T *win)
 {
   // very simple now, but can become more complex later
@@ -160,16 +154,6 @@ bool hasFolding(linenr_T lnum, linenr_T *firstp, linenr_T *lastp)
 bool hasFoldingWin(win_T *const win, const linenr_T lnum, linenr_T *const firstp,
                    linenr_T *const lastp, const bool cache, foldinfo_T *const infop)
 {
-  bool had_folded = false;
-  linenr_T first = 0;
-  linenr_T last = 0;
-  linenr_T lnum_rel = lnum;
-  fold_T *fp;
-  int level = 0;
-  bool use_level = false;
-  bool maybe_small = false;
-  int low_level = 0;
-
   checkupdate(win);
 
   // Return quickly when there is no folding at all in this window.
@@ -180,11 +164,13 @@ bool hasFoldingWin(win_T *const win, const linenr_T lnum, linenr_T *const firstp
     return false;
   }
 
+  bool had_folded = false;
+  linenr_T first = 0;
+  linenr_T last = 0;
+
   if (cache) {
-    /*
-     * First look in cached info for displayed lines.  This is probably
-     * the fastest, but it can only be used if the entry is still valid.
-     */
+    // First look in cached info for displayed lines.  This is probably
+    // the fastest, but it can only be used if the entry is still valid.
     const int x = find_wl_entry(win, lnum);
     if (x >= 0) {
       first = win->w_lines[x].wl_lnum;
@@ -193,10 +179,15 @@ bool hasFoldingWin(win_T *const win, const linenr_T lnum, linenr_T *const firstp
     }
   }
 
+  linenr_T lnum_rel = lnum;
+  int level = 0;
+  int low_level = 0;
+  fold_T *fp;
+  bool maybe_small = false;
+  bool use_level = false;
+
   if (first == 0) {
-    /*
-     * Recursively search for a fold that contains "lnum".
-     */
+    // Recursively search for a fold that contains "lnum".
     garray_T *gap = &win->w_folds;
     for (;;) {
       if (!foldFind(gap, lnum_rel, &fp)) {
@@ -224,7 +215,7 @@ bool hasFoldingWin(win_T *const win, const linenr_T lnum, linenr_T *const firstp
       // relative to containing fold.
       gap = &fp->fd_nested;
       lnum_rel -= fp->fd_top;
-      ++level;
+      level++;
     }
   }
 
@@ -311,42 +302,42 @@ foldinfo_T fold_info(win_T *win, linenr_T lnum)
 }
 
 // foldmethodIsManual() {{{2
-/// @return  TRUE if 'foldmethod' is "manual"
+/// @return  true if 'foldmethod' is "manual"
 int foldmethodIsManual(win_T *wp)
 {
   return wp->w_p_fdm[3] == 'u';
 }
 
 // foldmethodIsIndent() {{{2
-/// @return  TRUE if 'foldmethod' is "indent"
+/// @return  true if 'foldmethod' is "indent"
 int foldmethodIsIndent(win_T *wp)
 {
   return wp->w_p_fdm[0] == 'i';
 }
 
 // foldmethodIsExpr() {{{2
-/// @return  TRUE if 'foldmethod' is "expr"
+/// @return  true if 'foldmethod' is "expr"
 int foldmethodIsExpr(win_T *wp)
 {
   return wp->w_p_fdm[1] == 'x';
 }
 
 // foldmethodIsMarker() {{{2
-/// @return  TRUE if 'foldmethod' is "marker"
+/// @return  true if 'foldmethod' is "marker"
 int foldmethodIsMarker(win_T *wp)
 {
   return wp->w_p_fdm[2] == 'r';
 }
 
 // foldmethodIsSyntax() {{{2
-/// @return  TRUE if 'foldmethod' is "syntax"
+/// @return  true if 'foldmethod' is "syntax"
 int foldmethodIsSyntax(win_T *wp)
 {
   return wp->w_p_fdm[0] == 's';
 }
 
 // foldmethodIsDiff() {{{2
-/// @return  TRUE if 'foldmethod' is "diff"
+/// @return  true if 'foldmethod' is "diff"
 int foldmethodIsDiff(win_T *wp)
 {
   return wp->w_p_fdm[0] == 'd';
@@ -372,18 +363,17 @@ void closeFoldRecurse(pos_T pos)
 /// Open or Close folds for current window in lines "first" to "last".
 /// Used for "zo", "zO", "zc" and "zC" in Visual mode.
 ///
-/// @param opening     TRUE to open, FALSE to close
-/// @param recurse     TRUE to do it recursively
-/// @param had_visual  TRUE when Visual selection used
+/// @param opening     true to open, false to close
+/// @param recurse     true to do it recursively
+/// @param had_visual  true when Visual selection used
 void opFoldRange(pos_T firstpos, pos_T lastpos, int opening, int recurse, int had_visual)
 {
   int done = DONE_NOTHING;              // avoid error messages
   linenr_T first = firstpos.lnum;
   linenr_T last = lastpos.lnum;
-  linenr_T lnum;
   linenr_T lnum_next;
 
-  for (lnum = first; lnum <= last; lnum = lnum_next + 1) {
+  for (linenr_T lnum = first; lnum <= last; lnum = lnum_next + 1) {
     pos_T temp = { lnum, 0, 0 };
     lnum_next = lnum;
     // Opening one level only: next fold to open is after the one going to
@@ -426,12 +416,10 @@ void openFoldRecurse(pos_T pos)
 /// Open folds until the cursor line is not in a closed fold.
 void foldOpenCursor(void)
 {
-  int done;
-
   checkupdate(curwin);
   if (hasAnyFolding(curwin)) {
     for (;;) {
-      done = DONE_NOTHING;
+      int done = DONE_NOTHING;
       (void)setManualFold(curwin->w_cursor, true, false, &done);
       if (!(done & DONE_ACTION)) {
         break;
@@ -447,9 +435,7 @@ void newFoldLevel(void)
   newFoldLevelWin(curwin);
 
   if (foldmethodIsDiff(curwin) && curwin->w_p_scb) {
-    /*
-     * Set the same foldlevel in other windows in diff mode.
-     */
+    // Set the same foldlevel in other windows in diff mode.
     FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
       if (wp != curwin && foldmethodIsDiff(wp) && wp->w_p_scb) {
         wp->w_p_fdl = curwin->w_p_fdl;
@@ -461,15 +447,13 @@ void newFoldLevel(void)
 
 static void newFoldLevelWin(win_T *wp)
 {
-  fold_T *fp;
-
   checkupdate(wp);
   if (wp->w_fold_manual) {
     // Set all flags for the first level of folds to FD_LEVEL.  Following
     // manual open/close will then change the flags to FD_OPEN or
     // FD_CLOSED for those folds that don't use 'foldlevel'.
-    fp = (fold_T *)wp->w_folds.ga_data;
-    for (int i = 0; i < wp->w_folds.ga_len; ++i) {
+    fold_T *fp = (fold_T *)wp->w_folds.ga_data;
+    for (int i = 0; i < wp->w_folds.ga_len; i++) {
       fp[i].fd_flags = FD_LEVEL;
     }
     wp->w_fold_manual = false;
@@ -491,19 +475,18 @@ void foldCheckClose(void)
 }
 
 // checkCloseRec() {{{2
-static int checkCloseRec(garray_T *gap, linenr_T lnum, int level)
+static bool checkCloseRec(garray_T *gap, linenr_T lnum, int level)
 {
-  fold_T *fp;
-  int retval = FALSE;
+  bool retval = false;
 
-  fp = (fold_T *)gap->ga_data;
-  for (int i = 0; i < gap->ga_len; ++i) {
+  fold_T *fp = (fold_T *)gap->ga_data;
+  for (int i = 0; i < gap->ga_len; i++) {
     // Only manually opened folds may need to be closed.
     if (fp[i].fd_flags == FD_OPEN) {
       if (level <= 0 && (lnum < fp[i].fd_top
                          || lnum >= fp[i].fd_top + fp[i].fd_len)) {
         fp[i].fd_flags = FD_LEVEL;
-        retval = TRUE;
+        retval = true;
       } else {
         retval |= checkCloseRec(&fp[i].fd_nested, lnum - fp[i].fd_top,
                                 level - 1);
@@ -514,19 +497,19 @@ static int checkCloseRec(garray_T *gap, linenr_T lnum, int level)
 }
 
 // foldCreateAllowed() {{{2
-/// @return  TRUE if it's allowed to manually create or delete a fold or,
-///          give an error message and return FALSE if not.
+/// @return  true if it's allowed to manually create or delete a fold or,
+///          give an error message and return false if not.
 int foldManualAllowed(bool create)
 {
   if (foldmethodIsManual(curwin) || foldmethodIsMarker(curwin)) {
-    return TRUE;
+    return true;
   }
   if (create) {
     emsg(_("E350: Cannot create fold with current 'foldmethod'"));
   } else {
     emsg(_("E351: Cannot delete fold with current 'foldmethod'"));
   }
-  return FALSE;
+  return false;
 }
 
 // foldCreate() {{{2
@@ -534,13 +517,8 @@ int foldManualAllowed(bool create)
 /// window.
 void foldCreate(win_T *wp, pos_T start, pos_T end)
 {
-  fold_T *fp;
-  garray_T *gap;
-  garray_T fold_ga;
-  int i;
-  int cont;
-  int use_level = FALSE;
-  int closed = FALSE;
+  int use_level = false;
+  int closed = false;
   int level = 0;
   pos_T start_rel = start;
   pos_T end_rel = end;
@@ -561,11 +539,14 @@ void foldCreate(win_T *wp, pos_T start, pos_T end)
 
   checkupdate(wp);
 
+  int i;
+
   // Find the place to insert the new fold
-  gap = &wp->w_folds;
+  garray_T *gap = &wp->w_folds;
   if (gap->ga_len == 0) {
     i = 0;
   } else {
+    fold_T *fp;
     for (;;) {
       if (!foldFind(gap, start_rel.lnum, &fp)) {
         break;
@@ -599,10 +580,12 @@ void foldCreate(win_T *wp, pos_T start, pos_T end)
 
   ga_grow(gap, 1);
   {
-    fp = (fold_T *)gap->ga_data + i;
+    fold_T *fp = (fold_T *)gap->ga_data + i;
+    garray_T fold_ga;
     ga_init(&fold_ga, (int)sizeof(fold_T), 10);
 
     // Count number of folds that will be contained in the new fold.
+    int cont;
     for (cont = 0; i + cont < gap->ga_len; cont++) {
       if (fp[cont].fd_top > end_rel.lnum) {
         break;
@@ -668,7 +651,6 @@ void foldCreate(win_T *wp, pos_T start, pos_T end)
 void deleteFold(win_T *const wp, const linenr_T start, const linenr_T end, const int recursive,
                 const bool had_visual)
 {
-  fold_T *fp;
   fold_T *found_fp = NULL;
   linenr_T found_off = 0;
   bool maybe_small = false;
@@ -687,6 +669,7 @@ void deleteFold(win_T *const wp, const linenr_T start, const linenr_T end, const
     linenr_T lnum_off = 0;
     bool use_level = false;
     for (;;) {
+      fold_T *fp;
       if (!foldFind(gap, lnum - lnum_off, &fp)) {
         break;
       }
@@ -704,10 +687,10 @@ void deleteFold(win_T *const wp, const linenr_T start, const linenr_T end, const
       // check nested folds
       gap = &fp->fd_nested;
       lnum_off += fp->fd_top;
-      ++level;
+      level++;
     }
     if (found_ga == NULL) {
-      ++lnum;
+      lnum++;
     } else {
       lnum = found_fp->fd_top + found_fp->fd_len + found_off;
 
@@ -808,7 +791,7 @@ void foldUpdate(win_T *wp, linenr_T top, linenr_T bot)
     int save_got_int = got_int;
 
     // reset got_int here, otherwise it won't work
-    got_int = FALSE;
+    got_int = false;
     foldUpdateIEMS(wp, top, bot);
     got_int |= save_got_int;
   }
@@ -944,7 +927,7 @@ int foldMoveTo(const bool updown, const int dir, const long count)
       // Check nested folds (if any).
       gap = &fp->fd_nested;
       lnum_off += fp->fd_top;
-      ++level;
+      level++;
     }
     if (lnum_found != curwin->w_cursor.lnum) {
       if (retval == FAIL) {
@@ -970,15 +953,13 @@ void foldInitWin(win_T *new_win)
 
 // find_wl_entry() {{{2
 /// Find an entry in the win->w_lines[] array for buffer line "lnum".
-/// Only valid entries are considered (for entries where wl_valid is FALSE the
+/// Only valid entries are considered (for entries where wl_valid is false the
 /// line number can be wrong).
 ///
 /// @return  index of entry or -1 if not found.
 int find_wl_entry(win_T *win, linenr_T lnum)
 {
-  int i;
-
-  for (i = 0; i < win->w_lines_valid; ++i) {
+  for (int i = 0; i < win->w_lines_valid; i++) {
     if (win->w_lines[i].wl_valid) {
       if (lnum < win->w_lines[i].wl_lnum) {
         return -1;
@@ -995,13 +976,13 @@ int find_wl_entry(win_T *win, linenr_T lnum)
 /// Adjust the Visual area to include any fold at the start or end completely.
 void foldAdjustVisual(void)
 {
-  pos_T *start, *end;
-  char_u *ptr;
-
   if (!VIsual_active || !hasAnyFolding(curwin)) {
     return;
   }
 
+  pos_T *start, *end;
+  char_u *ptr;
+
   if (ltoreq(VIsual, curwin->w_cursor)) {
     start = &VIsual;
     end = &curwin->w_cursor;
@@ -1035,9 +1016,6 @@ void foldAdjustCursor(void)
 /// Will "clone" (i.e deep copy) a garray_T of folds.
 void cloneFoldGrowArray(garray_T *from, garray_T *to)
 {
-  fold_T *from_p;
-  fold_T *to_p;
-
   ga_init(to, from->ga_itemsize, from->ga_growsize);
 
   if (GA_EMPTY(from)) {
@@ -1046,8 +1024,8 @@ void cloneFoldGrowArray(garray_T *from, garray_T *to)
 
   ga_grow(to, from->ga_len);
 
-  from_p = (fold_T *)from->ga_data;
-  to_p = (fold_T *)to->ga_data;
+  fold_T *from_p = (fold_T *)from->ga_data;
+  fold_T *to_p = (fold_T *)to->ga_data;
 
   for (int i = 0; i < from->ga_len; i++) {
     to_p->fd_top = from_p->fd_top;
@@ -1055,9 +1033,9 @@ void cloneFoldGrowArray(garray_T *from, garray_T *to)
     to_p->fd_flags = from_p->fd_flags;
     to_p->fd_small = from_p->fd_small;
     cloneFoldGrowArray(&from_p->fd_nested, &to_p->fd_nested);
-    ++to->ga_len;
-    ++from_p;
-    ++to_p;
+    to->ga_len++;
+    from_p++;
+    to_p++;
   }
 }
 
@@ -1069,22 +1047,17 @@ void cloneFoldGrowArray(garray_T *from, garray_T *to)
 /// @return  false when there is no fold that contains "lnum".
 static bool foldFind(const garray_T *gap, linenr_T lnum, fold_T **fpp)
 {
-  linenr_T low, high;
-  fold_T *fp;
-
   if (gap->ga_len == 0) {
     *fpp = NULL;
     return false;
   }
 
-  /*
-   * Perform a binary search.
-   * "low" is lowest index of possible match.
-   * "high" is highest index of possible match.
-   */
-  fp = (fold_T *)gap->ga_data;
-  low = 0;
-  high = gap->ga_len - 1;
+  // Perform a binary search.
+  // "low" is lowest index of possible match.
+  // "high" is highest index of possible match.
+  fold_T *fp = (fold_T *)gap->ga_data;
+  linenr_T low = 0;
+  linenr_T high = gap->ga_len - 1;
   while (low <= high) {
     linenr_T i = (low + high) / 2;
     if (fp[i].fd_top > lnum) {
@@ -1110,10 +1083,9 @@ static int foldLevelWin(win_T *wp, linenr_T lnum)
   fold_T *fp;
   linenr_T lnum_rel = lnum;
   int level =  0;
-  garray_T *gap;
 
   // Recursively search for a fold that contains "lnum".
-  gap = &wp->w_folds;
+  garray_T *gap = &wp->w_folds;
   for (;;) {
     if (!foldFind(gap, lnum_rel, &fp)) {
       break;
@@ -1121,7 +1093,7 @@ static int foldLevelWin(win_T *wp, linenr_T lnum)
     // Check nested folds.  Line number is relative to containing fold.
     gap = &fp->fd_nested;
     lnum_rel -= fp->fd_top;
-    ++level;
+    level++;
   }
 
   return level;
@@ -1142,11 +1114,8 @@ static void checkupdate(win_T *wp)
 /// Repeat "count" times.
 static void setFoldRepeat(pos_T pos, long count, int do_open)
 {
-  int done;
-  long n;
-
-  for (n = 0; n < count; ++n) {
-    done = DONE_NOTHING;
+  for (int n = 0; n < count; n++) {
+    int done = DONE_NOTHING;
     (void)setManualFold(pos, do_open, false, &done);
     if (!(done & DONE_ACTION)) {
       // Only give an error message when no fold could be opened.
@@ -1162,18 +1131,15 @@ static void setFoldRepeat(pos_T pos, long count, int do_open)
 /// Open or close the fold in the current window which contains "lnum".
 /// Also does this for other windows in diff mode when needed.
 ///
-/// @param opening  TRUE when opening, FALSE when closing
-/// @param recurse  TRUE when closing/opening recursive
+/// @param opening  true when opening, false when closing
+/// @param recurse  true when closing/opening recursive
 static linenr_T setManualFold(pos_T pos, int opening, int recurse, int *donep)
 {
-  linenr_T lnum = pos.lnum;
   if (foldmethodIsDiff(curwin) && curwin->w_p_scb) {
     linenr_T dlnum;
 
-    /*
-     * Do the same operation in other windows in diff mode.  Calculate the
-     * line number from the diffs.
-     */
+    // Do the same operation in other windows in diff mode.  Calculate the
+    // line number from the diffs.
     FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
       if (wp != curwin && foldmethodIsDiff(wp) && wp->w_p_scb) {
         dlnum = diff_lnum_win(curwin->w_cursor.lnum, wp);
@@ -1184,7 +1150,7 @@ static linenr_T setManualFold(pos_T pos, int opening, int recurse, int *donep)
     }
   }
 
-  return setManualFoldWin(curwin, lnum, opening, recurse, donep);
+  return setManualFoldWin(curwin, pos.lnum, opening, recurse, donep);
 }
 
 // setManualFoldWin() {{{2
@@ -1194,31 +1160,27 @@ static linenr_T setManualFold(pos_T pos, int opening, int recurse, int *donep)
 /// When "donep" is NULL give an error message when no fold was found for
 /// "lnum", but only if "wp" is "curwin".
 ///
-/// @param opening  TRUE when opening, FALSE when closing
-/// @param recurse  TRUE when closing/opening recursive
+/// @param opening  true when opening, false when closing
+/// @param recurse  true when closing/opening recursive
 ///
 /// @return         the line number of the next line that could be closed.
-///                 It's only valid when "opening" is TRUE!
+///                 It's only valid when "opening" is true!
 static linenr_T setManualFoldWin(win_T *wp, linenr_T lnum, int opening, int recurse, int *donep)
 {
   fold_T *fp;
   fold_T *fp2;
   fold_T *found = NULL;
-  int j;
   int level = 0;
-  int use_level = FALSE;
-  int found_fold = FALSE;
-  garray_T *gap;
+  bool use_level = false;
+  bool found_fold = false;
   linenr_T next = MAXLNUM;
   linenr_T off = 0;
   int done = 0;
 
   checkupdate(wp);
 
-  /*
-   * Find the fold, open or close it.
-   */
-  gap = &wp->w_folds;
+  // Find the fold, open or close it.
+  garray_T *gap = &wp->w_folds;
   for (;;) {
     if (!foldFind(gap, lnum, &fp)) {
       // If there is a following fold, continue there next time.
@@ -1229,7 +1191,7 @@ static linenr_T setManualFoldWin(win_T *wp, linenr_T lnum, int opening, int recu
     }
 
     // lnum is inside this fold
-    found_fold = TRUE;
+    found_fold = true;
 
     // If there is a following fold, continue there next time.
     if (fp + 1 < (fold_T *)gap->ga_data + gap->ga_len) {
@@ -1238,14 +1200,14 @@ static linenr_T setManualFoldWin(win_T *wp, linenr_T lnum, int opening, int recu
 
     // Change from level-dependent folding to manual.
     if (use_level || fp->fd_flags == FD_LEVEL) {
-      use_level = TRUE;
+      use_level = true;
       if (level >= wp->w_p_fdl) {
         fp->fd_flags = FD_CLOSED;
       } else {
         fp->fd_flags = FD_OPEN;
       }
       fp2 = (fold_T *)fp->fd_nested.ga_data;
-      for (j = 0; j < fp->fd_nested.ga_len; ++j) {
+      for (int j = 0; j < fp->fd_nested.ga_len; j++) {
         fp2[j].fd_flags = FD_LEVEL;
       }
     }
@@ -1273,7 +1235,7 @@ static linenr_T setManualFoldWin(win_T *wp, linenr_T lnum, int opening, int recu
     gap = &fp->fd_nested;
     lnum -= fp->fd_top;
     off += fp->fd_top;
-    ++level;
+    level++;
   }
   if (found_fold) {
     // When closing and not recurse, close deepest open fold.
@@ -1301,10 +1263,8 @@ static linenr_T setManualFoldWin(win_T *wp, linenr_T lnum, int opening, int recu
 /// Open all nested folds in fold "fpr" recursively.
 static void foldOpenNested(fold_T *fpr)
 {
-  fold_T *fp;
-
-  fp = (fold_T *)fpr->fd_nested.ga_data;
-  for (int i = 0; i < fpr->fd_nested.ga_len; ++i) {
+  fold_T *fp = (fold_T *)fpr->fd_nested.ga_data;
+  for (int i = 0; i < fpr->fd_nested.ga_len; i++) {
     foldOpenNested(&fp[i]);
     fp[i].fd_flags = FD_OPEN;
   }
@@ -1390,14 +1350,12 @@ void foldMarkAdjust(win_T *wp, linenr_T line1, linenr_T line2, linenr_T amount,
 static void foldMarkAdjustRecurse(win_T *wp, garray_T *gap, linenr_T line1, linenr_T line2,
                                   linenr_T amount, linenr_T amount_after)
 {
-  fold_T *fp;
-  linenr_T last;
-  linenr_T top;
-
   if (gap->ga_len == 0) {
     return;
   }
 
+  linenr_T top;
+
   // In Insert mode an inserted line at the top of a fold is considered part
   // of the fold, otherwise it isn't.
   if ((State & MODE_INSERT) && amount == (linenr_T)1 && line2 == MAXLNUM) {
@@ -1407,25 +1365,22 @@ static void foldMarkAdjustRecurse(win_T *wp, garray_T *gap, linenr_T line1, line
   }
 
   // Find the fold containing or just below "line1".
+  fold_T *fp;
   (void)foldFind(gap, line1, &fp);
 
-  /*
-   * Adjust all folds below "line1" that are affected.
-   */
-  for (int i = (int)(fp - (fold_T *)gap->ga_data); i < gap->ga_len; ++i, ++fp) {
-    /*
-     * Check for these situations:
-     *    1  2  3
-     *    1  2  3
-     * line1     2      3  4  5
-     *       2  3  4  5
-     *       2  3  4  5
-     * line2     2      3  4  5
-     *          3     5  6
-     *          3     5  6
-     */
-
-    last = fp->fd_top + fp->fd_len - 1;     // last line of fold
+  // Adjust all folds below "line1" that are affected.
+  for (int i = (int)(fp - (fold_T *)gap->ga_data); i < gap->ga_len; i++, fp++) {
+    // Check for these situations:
+    //    1  2  3
+    //    1  2  3
+    // line1     2      3  4  5
+    //       2  3  4  5
+    //       2  3  4  5
+    // line2     2      3  4  5
+    //          3     5  6
+    //          3     5  6
+
+    linenr_T last = fp->fd_top + fp->fd_len - 1;     // last line of fold
 
     // 1. fold completely above line1: nothing to do
     if (last < line1) {
@@ -1498,13 +1453,11 @@ int getDeepestNesting(win_T *wp)
 
 static int getDeepestNestingRecurse(garray_T *gap)
 {
-  int level;
   int maxlevel = 0;
-  fold_T *fp;
 
-  fp = (fold_T *)gap->ga_data;
-  for (int i = 0; i < gap->ga_len; ++i) {
-    level = getDeepestNestingRecurse(&fp[i].fd_nested) + 1;
+  fold_T *fp = (fold_T *)gap->ga_data;
+  for (int i = 0; i < gap->ga_len; i++) {
+    int level = getDeepestNestingRecurse(&fp[i].fd_nested) + 1;
     if (level > maxlevel) {
       maxlevel = level;
     }
@@ -1622,14 +1575,13 @@ static void foldCreateMarkers(win_T *wp, pos_T start, pos_T end)
 static void foldAddMarker(buf_T *buf, pos_T pos, const char_u *marker, size_t markerlen)
 {
   char_u *cms = buf->b_p_cms;
-  char_u *line;
   char_u *newline;
   char_u *p = (char_u *)strstr((char *)buf->b_p_cms, "%s");
   bool line_is_comment = false;
   linenr_T lnum = pos.lnum;
 
   // Allocate a new line: old-line + 'cms'-start + marker + 'cms'-end
-  line = ml_get_buf(buf, lnum, false);
+  char_u *line = ml_get_buf(buf, lnum, false);
   size_t line_len = STRLEN(line);
   size_t added = 0;
 
@@ -1681,14 +1633,12 @@ static void deleteFoldMarkers(win_T *wp, fold_T *fp, int recursive, linenr_T lnu
 /// close-marker.
 static void foldDelMarker(buf_T *buf, linenr_T lnum, char_u *marker, size_t markerlen)
 {
-  char_u *newline;
-  char_u *cms = buf->b_p_cms;
-  char_u *cms2;
-
   // end marker may be missing and fold extends below the last line
   if (lnum > buf->b_ml.ml_line_count) {
     return;
   }
+
+  char_u *cms = buf->b_p_cms;
   char_u *line = ml_get_buf(buf, lnum, false);
   for (char_u *p = line; *p != NUL; p++) {
     if (STRNCMP(p, marker, markerlen) != 0) {
@@ -1697,11 +1647,11 @@ static void foldDelMarker(buf_T *buf, linenr_T lnum, char_u *marker, size_t mark
     // Found the marker, include a digit if it's there.
     size_t len = markerlen;
     if (ascii_isdigit(p[len])) {
-      ++len;
+      len++;
     }
     if (*cms != NUL) {
       // Also delete 'commentstring' if it matches.
-      cms2 = (char_u *)strstr((char *)cms, "%s");
+      char_u *cms2 = (char_u *)strstr((char *)cms, "%s");
       if (p - line >= cms2 - cms
           && STRNCMP(p - (cms2 - cms), cms, cms2 - cms) == 0
           && STRNCMP(p + len, cms2 + 2, STRLEN(cms2 + 2)) == 0) {
@@ -1711,7 +1661,7 @@ static void foldDelMarker(buf_T *buf, linenr_T lnum, char_u *marker, size_t mark
     }
     if (u_save(lnum - 1, lnum + 1) == OK) {
       // Make new line: text-before-marker + text-after-marker
-      newline = xmalloc(STRLEN(line) - len + 1);
+      char_u *newline = xmalloc(STRLEN(line) - len + 1);
       assert(p >= line);
       memcpy(newline, line, (size_t)(p - line));
       STRCPY(newline + (p - line), p + len);
@@ -1737,26 +1687,23 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume, foldinfo_T foldin
 {
   char_u *text = NULL;
   // an error occurred when evaluating 'fdt' setting
-  static int got_fdt_error = FALSE;
+  static bool got_fdt_error = false;
   int save_did_emsg = did_emsg;
   static win_T *last_wp = NULL;
   static linenr_T last_lnum = 0;
 
   if (last_wp == NULL || last_wp != wp || last_lnum > lnum || last_lnum == 0) {
     // window changed, try evaluating foldtext setting once again
-    got_fdt_error = FALSE;
+    got_fdt_error = false;
   }
 
   if (!got_fdt_error) {
     // a previous error should not abort evaluating 'foldexpr'
-    did_emsg = FALSE;
+    did_emsg = false;
   }
 
   if (*wp->w_p_fdt != NUL) {
     char dashes[MAX_LEVEL + 2];
-    win_T *save_curwin;
-    int level;
-    char_u *p;
 
     // Set "v:foldstart" and "v:foldend".
     set_vim_var_nr(VV_FOLDSTART, (varnumber_T)lnum);
@@ -1764,7 +1711,7 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume, foldinfo_T foldin
 
     // Set "v:folddashes" to a string of "level" dashes.
     // Set "v:foldlevel" to "level".
-    level = foldinfo.fi_level;
+    int level = foldinfo.fi_level;
     if (level > (int)sizeof(dashes) - 1) {
       level = (int)sizeof(dashes) - 1;
     }
@@ -1775,7 +1722,7 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume, foldinfo_T foldin
 
     // skip evaluating foldtext on errors
     if (!got_fdt_error) {
-      save_curwin = curwin;
+      win_T *save_curwin = curwin;
       curwin = wp;
       curbuf = wp->w_buffer;
 
@@ -1786,7 +1733,7 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume, foldinfo_T foldin
       emsg_silent--;
 
       if (text == NULL || did_emsg) {
-        got_fdt_error = TRUE;
+        got_fdt_error = true;
       }
 
       curwin = save_curwin;
@@ -1803,6 +1750,7 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume, foldinfo_T foldin
     if (text != NULL) {
       // Replace unprintable characters, if there are any.  But
       // replace a TAB with a space.
+      char_u *p;
       for (p = text; *p != NUL; p++) {
         int len = utfc_ptr2len((char *)p);
 
@@ -1840,11 +1788,6 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume, foldinfo_T foldin
 /// Remove 'foldmarker' and 'commentstring' from "str" (in-place).
 void foldtext_cleanup(char_u *str)
 {
-  char_u *s;
-  char_u *p;
-  bool did1 = false;
-  bool did2 = false;
-
   // Ignore leading and trailing white space in 'commentstring'.
   char_u *cms_start = (char_u *)skipwhite((char *)curbuf->b_p_cms);
   size_t cms_slen = STRLEN(cms_start);
@@ -1865,13 +1808,16 @@ void foldtext_cleanup(char_u *str)
     }
 
     // skip "%s" and white space after it
-    s = (char_u *)skipwhite((char *)cms_end + 2);
+    char_u *s = (char_u *)skipwhite((char *)cms_end + 2);
     cms_elen -= (size_t)(s - cms_end);
     cms_end = s;
   }
   parseMarker(curwin);
 
-  for (s = str; *s != NUL;) {
+  bool did1 = false;
+  bool did2 = false;
+
+  for (char_u *s = str; *s != NUL;) {
     size_t len = 0;
     if (STRNCMP(s, curwin->w_p_fmr, foldstartmarkerlen) == 0) {
       len = foldstartmarkerlen;
@@ -1880,11 +1826,12 @@ void foldtext_cleanup(char_u *str)
     }
     if (len > 0) {
       if (ascii_isdigit(s[len])) {
-        ++len;
+        len++;
       }
 
       // May remove 'commentstring' start.  Useful when it's a double
       // quote and we already removed a double quote.
+      char_u *p;
       for (p = s; p > str && ascii_iswhite(p[-1]); p--) {}
       if (p >= str + cms_slen
           && STRNCMP(p - cms_slen, cms_start, cms_slen) == 0) {
@@ -1903,7 +1850,7 @@ void foldtext_cleanup(char_u *str)
     }
     if (len != 0) {
       while (ascii_iswhite(s[len])) {
-        ++len;
+        len++;
       }
       STRMOVE(s, s + len);
     } else {
@@ -1920,10 +1867,6 @@ void foldtext_cleanup(char_u *str)
 /// IEMS = "Indent Expr Marker Syntax"
 static void foldUpdateIEMS(win_T *const wp, linenr_T top, linenr_T bot)
 {
-  fline_T fline;
-  LevelGetter getlevel = NULL;
-  fold_T *fp;
-
   // Avoid problems when being called recursively.
   if (invalid_top != (linenr_T)0) {
     return;
@@ -1955,6 +1898,8 @@ static void foldUpdateIEMS(win_T *const wp, linenr_T top, linenr_T bot)
     top = wp->w_buffer->b_ml.ml_line_count;
   }
 
+  fline_T fline;
+
   fold_changed = false;
   fline.wp = wp;
   fline.off = 0;
@@ -1967,6 +1912,8 @@ static void foldUpdateIEMS(win_T *const wp, linenr_T top, linenr_T bot)
   invalid_top = top;
   invalid_bot = bot;
 
+  LevelGetter getlevel = NULL;
+
   if (foldmethodIsMarker(wp)) {
     getlevel = foldlevelMarker;
 
@@ -2032,13 +1979,11 @@ static void foldUpdateIEMS(win_T *const wp, linenr_T top, linenr_T bot)
     }
   }
 
-  /*
-   * If folding is defined by the syntax, it is possible that a change in
-   * one line will cause all sub-folds of the current fold to change (e.g.,
-   * closing a C-style comment can cause folds in the subsequent lines to
-   * appear). To take that into account we should adjust the value of "bot"
-   * to point to the end of the current fold:
-   */
+  // If folding is defined by the syntax, it is possible that a change in
+  // one line will cause all sub-folds of the current fold to change (e.g.,
+  // closing a C-style comment can cause folds in the subsequent lines to
+  // appear). To take that into account we should adjust the value of "bot"
+  // to point to the end of the current fold:
   if (foldlevelSyntax == getlevel) {
     garray_T *gap = &wp->w_folds;
     fold_T *fpn = NULL;
@@ -2050,7 +1995,7 @@ static void foldUpdateIEMS(win_T *const wp, linenr_T top, linenr_T bot)
       if (!foldFind(gap, lnum_rel, &fpn)) {
         break;
       }
-      ++current_fdl;
+      current_fdl++;
 
       fold_start_lnum += fpn->fd_top;
       gap = &fpn->fd_nested;
@@ -2071,6 +2016,9 @@ static void foldUpdateIEMS(win_T *const wp, linenr_T top, linenr_T bot)
   if (start > end && end < wp->w_buffer->b_ml.ml_line_count) {
     end = start;
   }
+
+  fold_T *fp;
+
   while (!got_int) {
     // Always stop at the end of the file ("end" can be past the end of
     // the file).
@@ -2115,7 +2063,7 @@ static void foldUpdateIEMS(win_T *const wp, linenr_T top, linenr_T bot)
       if (fline.lnum == wp->w_buffer->b_ml.ml_line_count) {
         break;
       }
-      ++fline.lnum;
+      fline.lnum++;
       fline.lvl = fline.lvl_next;
       getlevel(&fline);
     }
@@ -2173,23 +2121,12 @@ static linenr_T foldUpdateIEMSRecurse(garray_T *const gap, const int level,
                                       const linenr_T startlnum, fline_T *const flp,
                                       LevelGetter getlevel, linenr_T bot, const char topflags)
 {
-  linenr_T ll;
   fold_T *fp = NULL;
-  fold_T *fp2;
-  int lvl = level;
-  linenr_T startlnum2 = startlnum;
-  const linenr_T firstlnum = flp->lnum;     // first lnum we got
-  int i;
-  bool finish = false;
-  const linenr_T linecount = flp->wp->w_buffer->b_ml.ml_line_count - flp->off;
-  int concat;
-
-  /*
-   * If using the marker method, the start line is not the start of a fold
-   * at the level we're dealing with and the level is non-zero, we must use
-   * the previous fold.  But ignore a fold that starts at or below
-   * startlnum, it must be deleted.
-   */
+
+  // If using the marker method, the start line is not the start of a fold
+  // at the level we're dealing with and the level is non-zero, we must use