Scope variables in move.c

1 files changed, 102 insertions, 157 deletions

diff --git a/src/nvim/move.c b/src/nvim/move.c
index f78610cb82..2a1f722e95 100644
--- a/src/nvim/move.c
+++ b/src/nvim/move.c
@@ -54,11 +54,8 @@ typedef struct {
  */
 static void comp_botline(win_T *wp)
 {
-  int n;
   linenr_T lnum;
   int done;
-  linenr_T last;
-  bool folded;
 
   /*
    * If w_cline_row is valid, start there.
@@ -74,18 +71,17 @@ static void comp_botline(win_T *wp)
   }
 
   for (; lnum <= wp->w_buffer->b_ml.ml_line_count; ++lnum) {
-    last = lnum;
-    folded = false;
-    if (hasFoldingWin(wp, lnum, NULL, &last, true, NULL)) {
+    int n;
+    linenr_T last = lnum;
+    bool folded = hasFoldingWin(wp, lnum, NULL, &last, true, NULL);
+    if (folded) {
       n = 1;
-      folded = true;
-    } else if (lnum == wp->w_topline)
+    } else if (lnum == wp->w_topline) {
       n = plines_win_nofill(wp, lnum, true) + wp->w_topfill;
-    else
+    } else {
       n = plines_win(wp, lnum, true);
-    if (
-      lnum <= wp->w_cursor.lnum && last >= wp->w_cursor.lnum
-      ) {
+    }
+    if (lnum <= wp->w_cursor.lnum && last >= wp->w_cursor.lnum) {
       wp->w_cline_row = done;
       wp->w_cline_height = n;
       wp->w_cline_folded = folded;
@@ -134,12 +130,8 @@ void update_topline_redraw(void)
  */
 void update_topline(void)
 {
-  long line_count;
-  int halfheight;
-  long n;
   linenr_T old_topline;
   int old_topfill;
-  linenr_T lnum;
   bool check_topline = false;
   bool check_botline = false;
   long save_so = p_so;
@@ -198,16 +190,16 @@ void update_topline(void)
       check_topline = true;
 
     if (check_topline) {
-      halfheight = curwin->w_height / 2 - 1;
+      int halfheight = curwin->w_height / 2 - 1;
       if (halfheight < 2)
         halfheight = 2;
-
+      long n;
       if (hasAnyFolding(curwin)) {
         /* Count the number of logical lines between the cursor and
          * topline + p_so (approximation of how much will be
          * scrolled). */
         n = 0;
-        for (lnum = curwin->w_cursor.lnum;
+        for (linenr_T lnum = curwin->w_cursor.lnum;
              lnum < curwin->w_topline + p_so; ++lnum) {
           ++n;
           /* stop at end of file or when we know we are far off */
@@ -221,9 +213,9 @@ void update_topline(void)
       /* If we weren't very close to begin with, we scroll to put the
        * cursor in the middle of the window.  Otherwise put the cursor
        * near the top of the window. */
-      if (n >= halfheight)
+      if (n >= halfheight) {
         scroll_cursor_halfway(false);
-      else {
+      } else {
         scroll_cursor_top(scrolljump_value(), false);
         check_botline = true;
       }
@@ -257,7 +249,7 @@ void update_topline(void)
           /* Cursor is (a few lines) above botline, check if there are
            * 'scrolloff' window lines below the cursor.  If not, need to
            * scroll. */
-          n = curwin->w_empty_rows;
+          int n = curwin->w_empty_rows;
           loff.lnum = curwin->w_cursor.lnum;
           /* In a fold go to its last line. */
           (void)hasFolding(loff.lnum, NULL, &loff.lnum);
@@ -275,17 +267,18 @@ void update_topline(void)
           if (n >= p_so)
             /* sufficient context, no need to scroll */
             check_botline = false;
-        } else
+        } else {
           /* sufficient context, no need to scroll */
           check_botline = false;
+        }
       }
       if (check_botline) {
+        long line_count = 0;
         if (hasAnyFolding(curwin)) {
           /* Count the number of logical lines between the cursor and
            * botline - p_so (approximation of how much will be
            * scrolled). */
-          line_count = 0;
-          for (lnum = curwin->w_cursor.lnum;
+          for (linenr_T lnum = curwin->w_cursor.lnum;
                lnum >= curwin->w_botline - p_so; --lnum) {
             ++line_count;
             /* stop at end of file or when we know we are far off */
@@ -354,15 +347,13 @@ static int scrolljump_value(void)
  */
 static bool check_top_offset(void)
 {
-  lineoff_T loff;
-  int n;
-
   if (curwin->w_cursor.lnum < curwin->w_topline + p_so
       || hasAnyFolding(curwin)
       ) {
+    lineoff_T loff;
     loff.lnum = curwin->w_cursor.lnum;
     loff.fill = 0;
-    n = curwin->w_topfill;          /* always have this context */
+    int n = curwin->w_topfill;          /* always have this context */
     /* Count the visible screen lines above the cursor line. */
     while (n < p_so) {
       topline_back(&loff);
@@ -532,20 +523,14 @@ void validate_cursor(void)
  */
 static void curs_rows(win_T *wp)
 {
-  linenr_T lnum;
-  int i;
-  int all_invalid;
-  bool valid;
-  long fold_count;
-
   /* Check if wp->w_lines[].wl_size is invalid */
-  all_invalid = (!redrawing()
-                 || wp->w_lines_valid == 0
-                 || wp->w_lines[0].wl_lnum > wp->w_topline);
-  i = 0;
+  int all_invalid = (!redrawing()
+                     || wp->w_lines_valid == 0
+                     || wp->w_lines[0].wl_lnum > wp->w_topline);
+  int i = 0;
   wp->w_cline_row = 0;
-  for (lnum = wp->w_topline; lnum < wp->w_cursor.lnum; ++i) {
-    valid = false;
+  for (linenr_T lnum = wp->w_topline; lnum < wp->w_cursor.lnum; ++i) {
+    bool valid = false;
     if (!all_invalid && i < wp->w_lines_valid) {
       if (wp->w_lines[i].wl_lnum < lnum || !wp->w_lines[i].wl_valid)
         continue;                       /* skip changed or deleted lines */
@@ -557,8 +542,9 @@ static void curs_rows(win_T *wp)
                                             || wp->w_buffer->b_mod_top
                                             > wp->w_lines[i].wl_lastlnum + 1)
           valid = true;
-      } else if (wp->w_lines[i].wl_lnum > lnum)
+      } else if (wp->w_lines[i].wl_lnum > lnum) {
         --i;                            /* hold at inserted lines */
+      }
     }
     if (valid
         && (lnum != wp->w_topline || !wp->w_p_diff)
@@ -569,17 +555,18 @@ static void curs_rows(win_T *wp)
         break;
       wp->w_cline_row += wp->w_lines[i].wl_size;
     } else {
-      fold_count = foldedCount(wp, lnum, NULL);
+      long fold_count = foldedCount(wp, lnum, NULL);
       if (fold_count) {
         lnum += fold_count;
         if (lnum > wp->w_cursor.lnum)
           break;
         ++wp->w_cline_row;
-      } else if (lnum == wp->w_topline)
+      } else if (lnum == wp->w_topline) {
         wp->w_cline_row += plines_win_nofill(wp, lnum++, true)
                            + wp->w_topfill;
-      else
+      } else {
         wp->w_cline_row += plines_win(wp, lnum++, true);
+      }
     }
   }
 
@@ -658,16 +645,12 @@ static void validate_cheight(void)
  */
 void validate_cursor_col(void)
 {
-  colnr_T off;
-  colnr_T col;
-  int width;
-
   validate_virtcol();
   if (!(curwin->w_valid & VALID_WCOL)) {
-    col = curwin->w_virtcol;
-    off = curwin_col_off();
+    colnr_T col = curwin->w_virtcol;
+    colnr_T off = curwin_col_off();
     col += off;
-    width = curwin->w_width - off + curwin_col_off2();
+    int width = curwin->w_width - off + curwin_col_off2();
 
     /* long line wrapping, adjust curwin->w_wrow */
     if (curwin->w_p_wrap
@@ -725,19 +708,12 @@ int curwin_col_off2(void)
  * Also updates curwin->w_wrow and curwin->w_cline_row.
  * Also updates curwin->w_leftcol.
  */
-void 
-curs_columns (
+void curs_columns(
     int may_scroll                 /* when true, may scroll horizontally */
 )
 {
-  int diff;
-  int extra;                    /* offset for first screen line */
-  int off_left, off_right;
   int n;
-  int p_lines;
   int width = 0;
-  int textwidth;
-  int new_leftcol;
   colnr_T startcol;
   colnr_T endcol;
   colnr_T prev_skipcol;
@@ -766,7 +742,7 @@ curs_columns (
   if (startcol > dollar_vcol)
     dollar_vcol = -1;
 
-  extra = curwin_col_off();
+  int extra = curwin_col_off();
   curwin->w_wcol = curwin->w_virtcol + extra;
   endcol += extra;
 
@@ -775,7 +751,7 @@ curs_columns (
    */
   curwin->w_wrow = curwin->w_cline_row;
 
-  textwidth = curwin->w_width - extra;
+  int textwidth = curwin->w_width - extra;
   if (textwidth <= 0) {
     /* No room for text, put cursor in last char of window. */
     curwin->w_wcol = curwin->w_width - 1;
@@ -813,16 +789,15 @@ curs_columns (
      * extra
      */
     assert(p_siso <= INT_MAX);
-    off_left = startcol - curwin->w_leftcol - (int)p_siso;
-    off_right = endcol - curwin->w_leftcol - curwin->w_width + (int)p_siso + 1;
+    int off_left = startcol - curwin->w_leftcol - (int)p_siso;
+    int off_right =
+        endcol - curwin->w_leftcol - curwin->w_width + (int)p_siso + 1;
     if (off_left < 0 || off_right > 0) {
-      if (off_left < 0)
-        diff = -off_left;
-      else
-        diff = off_right;
+      int diff = (off_left < 0) ? -off_left: off_right;
 
       /* When far off or not enough room on either side, put cursor in
        * middle of window. */
+      int new_leftcol;
       if (p_ss == 0 || diff >= textwidth / 2 || off_right >= off_left)
         new_leftcol = curwin->w_wcol - extra - textwidth / 2;
       else {
@@ -858,7 +833,7 @@ curs_columns (
 
   prev_skipcol = curwin->w_skipcol;
 
-  p_lines = 0;
+  int p_lines = 0;
   if ((curwin->w_wrow >= curwin->w_height
        || ((prev_skipcol > 0
             || curwin->w_wrow + p_so >= curwin->w_height)
@@ -933,12 +908,14 @@ curs_columns (
     }
 
     extra = ((int)prev_skipcol - (int)curwin->w_skipcol) / width;
-    if (extra > 0)
+    if (extra > 0) {
       win_ins_lines(curwin, 0, extra, false, false);
-    else if (extra < 0)
+    } else if (extra < 0) {
       win_del_lines(curwin, 0, -extra, false, false);
-  } else
+    }
+  } else {
     curwin->w_skipcol = 0;
+  }
   if (prev_skipcol != curwin->w_skipcol)
     redraw_later(NOT_VALID);
 
@@ -961,10 +938,6 @@ scrolldown (
 )
 {
   int done = 0;                /* total # of physical lines done */
-  int wrow;
-  bool moved = false;
-
-  linenr_T first;
 
   /* Make sure w_topline is at the first of a sequence of folded lines. */
   (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
@@ -980,6 +953,7 @@ scrolldown (
       --curwin->w_topline;
       curwin->w_topfill = 0;
       /* A sequence of folded lines only counts for one logical line */
+      linenr_T first;
       if (hasFolding(curwin->w_topline, &first, NULL)) {
         ++done;
         if (!byfold)
@@ -1003,7 +977,7 @@ scrolldown (
    * Compute the row number of the last row of the cursor line
    * and move the cursor onto the displayed part of the window.
    */
-  wrow = curwin->w_wrow;
+  int wrow = curwin->w_wrow;
   if (curwin->w_p_wrap
       && curwin->w_width != 0
       ) {
@@ -1012,7 +986,9 @@ scrolldown (
     wrow += curwin->w_cline_height - 1 -
             curwin->w_virtcol / curwin->w_width;
   }
+  bool moved = false;
   while (wrow >= curwin->w_height && curwin->w_cursor.lnum > 1) {
+    linenr_T first;
     if (hasFolding(curwin->w_cursor.lnum, &first, NULL)) {
       --wrow;
       if (first == 1)
@@ -1041,15 +1017,13 @@ scrollup (
     int byfold              /* true: count a closed fold as one line */
 )
 {
-  linenr_T lnum;
-
   if (
     (byfold && hasAnyFolding(curwin))
     ||
     curwin->w_p_diff
     ) {
     /* count each sequence of folded lines as one logical line */
-    lnum = curwin->w_topline;
+    linenr_T lnum = curwin->w_topline;
     while (line_count--) {
       if (curwin->w_topfill > 0)
         --curwin->w_topfill;
@@ -1099,10 +1073,8 @@ check_topfill (
     bool down              /* when true scroll down when not enough space */
 )
 {
-  int n;
-
   if (wp->w_topfill > 0) {
-    n = plines_win_nofill(wp, wp->w_topline, true);
+    int n = plines_win_nofill(wp, wp->w_topline, true);
     if (wp->w_topfill + n > wp->w_height) {
       if (down && wp->w_topline > 1) {
         --wp->w_topline;
@@ -1122,9 +1094,7 @@ check_topfill (
  */
 static void max_topfill(void)
 {
-  int n;
-
-  n = plines_nofill(curwin->w_topline);
+  int n = plines_nofill(curwin->w_topline);
   if (n >= curwin->w_height)
     curwin->w_topfill = 0;
   else {
@@ -1140,7 +1110,6 @@ static void max_topfill(void)
  */
 void scrolldown_clamp(void)
 {
-  int end_row;
   int can_fill = (curwin->w_topfill
                   < diff_check_fill(curwin, curwin->w_topline));
 
@@ -1156,7 +1125,7 @@ void scrolldown_clamp(void)
    * and make sure it doesn't go off the screen. Make sure the cursor
    * doesn't go past 'scrolloff' lines from the screen end.
    */
-  end_row = curwin->w_wrow;
+  int end_row = curwin->w_wrow;
   if (can_fill)
     ++end_row;
   else
@@ -1189,8 +1158,6 @@ void scrolldown_clamp(void)
  */
 void scrollup_clamp(void)
 {
-  int start_row;
-
   if (curwin->w_topline == curbuf->b_ml.ml_line_count
       && curwin->w_topfill == 0
       )
@@ -1203,7 +1170,7 @@ void scrollup_clamp(void)
    * and make sure it doesn't go off the screen. Make sure the cursor
    * doesn't go before 'scrolloff' lines from the screen start.
    */
-  start_row = curwin->w_wrow - plines_nofill(curwin->w_topline)
+  int start_row = curwin->w_wrow - plines_nofill(curwin->w_topline)
               - curwin->w_topfill;
   if (curwin->w_p_wrap
       && curwin->w_width != 0
@@ -1309,9 +1276,6 @@ static void topline_botline(lineoff_T *lp)
 void scroll_cursor_top(int min_scroll, int always)
 {
   int scrolled = 0;
-  int extra = 0;
-  int used;
-  int i;
   linenr_T top;                 /* just above displayed lines */
   linenr_T bot;                 /* just below displayed lines */
   linenr_T old_topline = curwin->w_topline;
@@ -1331,7 +1295,7 @@ void scroll_cursor_top(int min_scroll, int always)
    * - at least 'scrolloff' lines above and below the cursor
    */
   validate_cheight();
-  used = curwin->w_cline_height;
+  int used = curwin->w_cline_height;
   if (curwin->w_cursor.lnum < curwin->w_topline)
     scrolled = used;
 
@@ -1345,20 +1309,15 @@ void scroll_cursor_top(int min_scroll, int always)
   new_topline = top + 1;
 
   /* count filler lines of the cursor window as context */
-  i = diff_check_fill(curwin, curwin->w_cursor.lnum);
-  used += i;
-  extra += i;
+  int extra = diff_check_fill(curwin, curwin->w_cursor.lnum);
+  used += extra;
 
   /*
    * Check if the lines from "top" to "bot" fit in the window.  If they do,
    * set new_topline and advance "top" and "bot" to include more lines.
    */
   while (top > 0) {
-    if (hasFolding(top, &top, NULL))
-      /* count one logical line for a sequence of folded lines */
-      i = 1;
-    else
-      i = plines(top);
+    int i = (hasFolding(top, &top, NULL)) ? 1 : plines(top);
     used += i;
     if (extra + i <= off && bot < curbuf->b_ml.ml_line_count) {
       if (hasFolding(bot, NULL, &bot))
@@ -1390,9 +1349,9 @@ void scroll_cursor_top(int min_scroll, int always)
    * This makes sure we get the same position when using "k" and "j"
    * in a small window.
    */
-  if (used > curwin->w_height)
+  if (used > curwin->w_height) {
     scroll_cursor_halfway(false);
-  else {
+  } else {
     /*
      * If "always" is false, only adjust topline to a lower value, higher
      * value may happen with wrapping lines
@@ -1451,19 +1410,16 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
   int used;
   int scrolled = 0;
   int extra = 0;
-  int i;
-  linenr_T line_count;
-  linenr_T old_topline = curwin->w_topline;
   lineoff_T loff;
   lineoff_T boff;
-  int old_topfill = curwin->w_topfill;
   int fill_below_window;
-  linenr_T old_botline = curwin->w_botline;
-  int old_valid = curwin->w_valid;
-  int old_empty_rows = curwin->w_empty_rows;
-  linenr_T cln;                     /* Cursor Line Number */
+  linenr_T old_topline    = curwin->w_topline;
+  int      old_topfill    = curwin->w_topfill;
+  linenr_T old_botline    = curwin->w_botline;
+  int      old_valid      = curwin->w_valid;
+  int      old_empty_rows = curwin->w_empty_rows;
+  linenr_T cln            = curwin->w_cursor.lnum; /* Cursor Line Number */
 
-  cln = curwin->w_cursor.lnum;
   if (set_topbot) {
     used = 0;
     curwin->w_botline = cln + 1;
@@ -1574,6 +1530,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
     }
   }
 
+  linenr_T line_count;
   /* curwin->w_empty_rows is larger, no need to scroll */
   if (scrolled <= 0)
     line_count = 0;
@@ -1585,6 +1542,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
     line_count = 0;
     boff.fill = curwin->w_topfill;
     boff.lnum = curwin->w_topline - 1;
+    int i;
     for (i = 0; i < scrolled && boff.lnum < curwin->w_botline; ) {
       botline_forw(&boff);
       i += boff.height;
@@ -1623,20 +1581,18 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
 void scroll_cursor_halfway(int atend)
 {
   int above = 0;
-  linenr_T topline;
   int topfill = 0;
   int below = 0;
-  int used;
   lineoff_T loff;
   lineoff_T boff;
   linenr_T old_topline = curwin->w_topline;
 
   loff.lnum = boff.lnum = curwin->w_cursor.lnum;
   (void)hasFolding(loff.lnum, &loff.lnum, &boff.lnum);
-  used = plines_nofill(loff.lnum);
+  int used = plines_nofill(loff.lnum);
   loff.fill = 0;
   boff.fill = 0;
-  topline = loff.lnum;
+  linenr_T topline = loff.lnum;
   while (topline > 1) {
     if (below <= above) {           /* add a line below the cursor first */
       if (boff.lnum < curbuf->b_ml.ml_line_count) {
@@ -1683,28 +1639,20 @@ void scroll_cursor_halfway(int atend)
  */
 void cursor_correct(void)
 {
-  int above = 0;                    /* screen lines above topline */
-  linenr_T topline;
-  int below = 0;                    /* screen lines below botline */
-  linenr_T botline;
-  int above_wanted, below_wanted;
-  linenr_T cln;                     /* Cursor Line Number */
-  int max_off;
-
   /*
    * How many lines we would like to have above/below the cursor depends on
    * whether the first/last line of the file is on screen.
    */
   assert(p_so <= INT_MAX);
-  above_wanted = (int)p_so;
-  below_wanted = (int)p_so;
+  int above_wanted = (int)p_so;
+  int below_wanted = (int)p_so;
   if (mouse_dragging > 0) {
     above_wanted = mouse_dragging - 1;
     below_wanted = mouse_dragging - 1;
   }
   if (curwin->w_topline == 1) {
     above_wanted = 0;
-    max_off = curwin->w_height / 2;
+    int max_off = curwin->w_height / 2;
     if (below_wanted > max_off)
       below_wanted = max_off;
   }
@@ -1713,7 +1661,7 @@ void cursor_correct(void)
       && mouse_dragging == 0
       ) {
     below_wanted = 0;
-    max_off = (curwin->w_height - 1) / 2;
+    int max_off = (curwin->w_height - 1) / 2;
     if (above_wanted > max_off)
       above_wanted = max_off;
   }
@@ -1722,7 +1670,7 @@ void cursor_correct(void)
    * If there are sufficient file-lines above and below the cursor, we can
    * return now.
    */
-  cln = curwin->w_cursor.lnum;
+  linenr_T cln = curwin->w_cursor.lnum; /* Cursor Line Number */
   if (cln >= curwin->w_topline + above_wanted
       && cln < curwin->w_botline - below_wanted
       && !hasAnyFolding(curwin)
@@ -1735,11 +1683,11 @@ void cursor_correct(void)
    * - the desired context lines are found
    * - the lines from the top is past the lines from the bottom
    */
-  topline = curwin->w_topline;
-  botline = curwin->w_botline - 1;
+  linenr_T topline = curwin->w_topline;
+  linenr_T botline = curwin->w_botline - 1;
   /* count filler lines as context */
-  above = curwin->w_topfill;
-  below = curwin->w_filler_rows;
+  int above = curwin->w_topfill; /* screen lines above topline */
+  int below = curwin->w_filler_rows; /* screen lines below botline */
   while ((above < above_wanted || below < below_wanted) && topline < botline) {
     if (below < below_wanted && (below <= above || above >= above_wanted)) {
       if (hasFolding(botline, &botline, NULL))
@@ -1973,46 +1921,44 @@ int onepage(int dir, long count)
  */
 static void get_scroll_overlap(lineoff_T *lp, int dir)
 {
-  int h1, h2, h3, h4;
   int min_height = curwin->w_height - 2;
-  lineoff_T loff0, loff1, loff2;
 
   if (lp->fill > 0)
     lp->height = 1;
   else
     lp->height = plines_nofill(lp->lnum);
-  h1 = lp->height;
+  int h1 = lp->height;
   if (h1 > min_height)
     return;             /* no overlap */
 
-  loff0 = *lp;
+  lineoff_T loff0 = *lp;
   if (dir > 0)
     botline_forw(lp);
   else
     topline_back(lp);
-  h2 = lp->height;
+  int h2 = lp->height;
   if (h2 == MAXCOL || h2 + h1 > min_height) {
     *lp = loff0;        /* no overlap */
     return;
   }
 
-  loff1 = *lp;
+  lineoff_T loff1 = *lp;
   if (dir > 0)
     botline_forw(lp);
   else
     topline_back(lp);
-  h3 = lp->height;
+  int h3 = lp->height;
   if (h3 == MAXCOL || h3 + h2 > min_height) {
     *lp = loff0;        /* no overlap */
     return;
   }
 
-  loff2 = *lp;
+  lineoff_T loff2 = *lp;
   if (dir > 0)
     botline_forw(lp);
   else
     topline_back(lp);
-  h4 = lp->height;
+  int h4 = lp->height;
   if (h4 == MAXCOL || h4 + h3 + h2 > min_height || h3 + h2 + h1 > min_height)
     *lp = loff1;        /* 1 line overlap */
   else
@@ -2028,7 +1974,6 @@ void halfpage(bool flag, linenr_T Prenum)
 {
   long scrolled = 0;
   int i;
-  int room;
 
   if (Prenum)
     curwin->w_p_scr = (Prenum > curwin->w_height) ?
@@ -2038,8 +1983,7 @@ void halfpage(bool flag, linenr_T Prenum)
                                               : curwin->w_height;
 
   validate_botline();
-  room = curwin->w_empty_rows;
-  room += curwin->w_filler_rows;
+  int room = curwin->w_empty_rows + curwin->w_filler_rows;
   if (flag) {
     /*
      * scroll the text up
@@ -2186,14 +2130,13 @@ void halfpage(bool flag, linenr_T Prenum)
 
 void do_check_cursorbind(void)
 {
-  linenr_T line = curwin->w_cursor.lnum;
-  colnr_T col = curwin->w_cursor.col;
-  colnr_T coladd = curwin->w_cursor.coladd;
+  linenr_T line    = curwin->w_cursor.lnum;
+  colnr_T col      = curwin->w_cursor.col;
+  colnr_T coladd   = curwin->w_cursor.coladd;
   colnr_T curswant = curwin->w_curswant;
   int set_curswant = curwin->w_set_curswant;
-  win_T       *old_curwin = curwin;
-  buf_T       *old_curbuf = curbuf;
-  int restart_edit_save;
+  win_T *old_curwin = curwin;
+  buf_T *old_curbuf = curbuf;
   int old_VIsual_select = VIsual_select;
   int old_VIsual_active = VIsual_active;
 
@@ -2220,10 +2163,12 @@ void do_check_cursorbind(void)
 
       /* Make sure the cursor is in a valid position.  Temporarily set
        * "restart_edit" to allow the cursor to be beyond the EOL. */
-      restart_edit_save = restart_edit;
-      restart_edit = true;
-      check_cursor();
-      restart_edit = restart_edit_save;
+      {
+        int restart_edit_save = restart_edit;
+        restart_edit = true;
+        check_cursor();
+        restart_edit = restart_edit_save;
+      }
       /* Correct cursor for multi-byte character. */
       if (has_mbyte)
         mb_adjust_cursor();