From 41778e2e10e43d6ba96b27e63fb392a8d6d64b01 Mon Sep 17 00:00:00 2001 From: Nicolas Cornu Date: Mon, 7 Sep 2015 15:03:47 +0200 Subject: win_T.w_cline_folded from int to bool --- src/nvim/move.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'src/nvim/move.c') diff --git a/src/nvim/move.c b/src/nvim/move.c index ac15d9e927..7e0d1ed775 100644 --- a/src/nvim/move.c +++ b/src/nvim/move.c @@ -58,7 +58,7 @@ static void comp_botline(win_T *wp) linenr_T lnum; int done; linenr_T last; - int folded; + bool folded; /* * If w_cline_row is valid, start there. @@ -75,10 +75,10 @@ static void comp_botline(win_T *wp) for (; lnum <= wp->w_buffer->b_ml.ml_line_count; ++lnum) { last = lnum; - folded = FALSE; + folded = false; if (hasFoldingWin(wp, lnum, NULL, &last, TRUE, NULL)) { n = 1; - folded = TRUE; + folded = true; } else if (lnum == wp->w_topline) n = plines_win_nofill(wp, lnum, TRUE) + wp->w_topfill; else @@ -596,15 +596,15 @@ static void curs_rows(win_T *wp) else wp->w_cline_height = plines_win(wp, wp->w_cursor.lnum, TRUE); wp->w_cline_folded = hasFoldingWin(wp, wp->w_cursor.lnum, - NULL, NULL, TRUE, NULL); + NULL, NULL, TRUE, NULL) == TRUE; } else if (i > wp->w_lines_valid) { /* a line that is too long to fit on the last screen line */ wp->w_cline_height = 0; wp->w_cline_folded = hasFoldingWin(wp, wp->w_cursor.lnum, - NULL, NULL, TRUE, NULL); + NULL, NULL, TRUE, NULL) == TRUE; } else { wp->w_cline_height = wp->w_lines[i].wl_size; - wp->w_cline_folded = wp->w_lines[i].wl_folded; + wp->w_cline_folded = wp->w_lines[i].wl_folded == TRUE; } } @@ -648,7 +648,7 @@ static void validate_cheight(void) + curwin->w_topfill; else curwin->w_cline_height = plines(curwin->w_cursor.lnum); - curwin->w_cline_folded = hasFolding(curwin->w_cursor.lnum, NULL, NULL); + curwin->w_cline_folded = hasFolding(curwin->w_cursor.lnum, NULL, NULL) == TRUE; curwin->w_valid |= VALID_CHEIGHT; } } -- cgit From 63a39015f5510e1b0be094ae9298f31bf339cc0f Mon Sep 17 00:00:00 2001 From: Nicolas Cornu Date: Tue, 8 Sep 2015 02:34:43 +0200 Subject: hasFoldingWin now return bool --- src/nvim/move.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/nvim/move.c') diff --git a/src/nvim/move.c b/src/nvim/move.c index 7e0d1ed775..6a00f66c52 100644 --- a/src/nvim/move.c +++ b/src/nvim/move.c @@ -596,12 +596,12 @@ static void curs_rows(win_T *wp) else wp->w_cline_height = plines_win(wp, wp->w_cursor.lnum, TRUE); wp->w_cline_folded = hasFoldingWin(wp, wp->w_cursor.lnum, - NULL, NULL, TRUE, NULL) == TRUE; + NULL, NULL, TRUE, NULL); } else if (i > wp->w_lines_valid) { /* a line that is too long to fit on the last screen line */ wp->w_cline_height = 0; wp->w_cline_folded = hasFoldingWin(wp, wp->w_cursor.lnum, - NULL, NULL, TRUE, NULL) == TRUE; + NULL, NULL, TRUE, NULL); } else { wp->w_cline_height = wp->w_lines[i].wl_size; wp->w_cline_folded = wp->w_lines[i].wl_folded == TRUE; -- cgit From 16e9c853dfdea32fcf187fda147cafebd3dfc5dd Mon Sep 17 00:00:00 2001 From: Nicolas Cornu Date: Mon, 7 Sep 2015 15:16:35 +0200 Subject: hasFolding return bool now --- src/nvim/move.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/nvim/move.c') diff --git a/src/nvim/move.c b/src/nvim/move.c index 6a00f66c52..55848bb257 100644 --- a/src/nvim/move.c +++ b/src/nvim/move.c @@ -648,7 +648,7 @@ static void validate_cheight(void) + curwin->w_topfill; else curwin->w_cline_height = plines(curwin->w_cursor.lnum); - curwin->w_cline_folded = hasFolding(curwin->w_cursor.lnum, NULL, NULL) == TRUE; + curwin->w_cline_folded = hasFolding(curwin->w_cursor.lnum, NULL, NULL); curwin->w_valid |= VALID_CHEIGHT; } } @@ -1177,7 +1177,7 @@ void scrolldown_clamp(void) --curwin->w_topline; curwin->w_topfill = 0; } - hasFolding(curwin->w_topline, &curwin->w_topline, NULL); + (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL); --curwin->w_botline; /* approximate w_botline */ curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE); } -- cgit From 600bb285f6e3d8926de78e747a59b77b6e6c4e87 Mon Sep 17 00:00:00 2001 From: Nicolas Cornu Date: Mon, 7 Sep 2015 15:49:50 +0200 Subject: Replace TRUE/FALSE with true/false in move.c --- src/nvim/move.c | 114 ++++++++++++++++++++++++++++---------------------------- 1 file changed, 57 insertions(+), 57 deletions(-) (limited to 'src/nvim/move.c') diff --git a/src/nvim/move.c b/src/nvim/move.c index 55848bb257..f78610cb82 100644 --- a/src/nvim/move.c +++ b/src/nvim/move.c @@ -76,13 +76,13 @@ 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)) { + if (hasFoldingWin(wp, lnum, NULL, &last, true, NULL)) { n = 1; folded = true; } else if (lnum == wp->w_topline) - n = plines_win_nofill(wp, lnum, TRUE) + wp->w_topfill; + n = plines_win_nofill(wp, lnum, true) + wp->w_topfill; else - n = plines_win(wp, lnum, TRUE); + n = plines_win(wp, lnum, true); if ( lnum <= wp->w_cursor.lnum && last >= wp->w_cursor.lnum ) { @@ -140,11 +140,11 @@ void update_topline(void) linenr_T old_topline; int old_topfill; linenr_T lnum; - int check_topline = FALSE; - int check_botline = FALSE; + bool check_topline = false; + bool check_botline = false; long save_so = p_so; - if (!screen_valid(TRUE)) + if (!screen_valid(true)) return; // If the window height is zero, just use the cursor line. @@ -188,14 +188,14 @@ void update_topline(void) * If the cursor is far below topline and there is no folding, * scrolling down is never needed. */ if (curwin->w_cursor.lnum < curwin->w_topline) - check_topline = TRUE; + check_topline = true; else if (check_top_offset()) - check_topline = TRUE; + check_topline = true; } /* Check if there are more filler lines than allowed. */ if (!check_topline && curwin->w_topfill > diff_check_fill(curwin, curwin->w_topline)) - check_topline = TRUE; + check_topline = true; if (check_topline) { halfheight = curwin->w_height / 2 - 1; @@ -222,15 +222,15 @@ void update_topline(void) * cursor in the middle of the window. Otherwise put the cursor * near the top of the window. */ if (n >= halfheight) - scroll_cursor_halfway(FALSE); + scroll_cursor_halfway(false); else { - scroll_cursor_top(scrolljump_value(), FALSE); - check_botline = TRUE; + scroll_cursor_top(scrolljump_value(), false); + check_botline = true; } } else { /* Make sure topline is the first line of a fold. */ (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL); - check_botline = TRUE; + check_botline = true; } } @@ -274,10 +274,10 @@ void update_topline(void) } if (n >= p_so) /* sufficient context, no need to scroll */ - check_botline = FALSE; + check_botline = false; } else /* sufficient context, no need to scroll */ - check_botline = FALSE; + check_botline = false; } if (check_botline) { if (hasAnyFolding(curwin)) { @@ -297,9 +297,9 @@ void update_topline(void) line_count = curwin->w_cursor.lnum - curwin->w_botline + 1 + p_so; if (line_count <= curwin->w_height + 1) - scroll_cursor_bot(scrolljump_value(), FALSE); + scroll_cursor_bot(scrolljump_value(), false); else - scroll_cursor_halfway(FALSE); + scroll_cursor_halfway(false); } } } @@ -349,10 +349,10 @@ static int scrolljump_value(void) } /* - * Return TRUE when there are not 'scrolloff' lines above the cursor for the + * Return true when there are not 'scrolloff' lines above the cursor for the * current window. */ -static int check_top_offset(void) +static bool check_top_offset(void) { lineoff_T loff; int n; @@ -374,9 +374,9 @@ static int check_top_offset(void) n += loff.height; } if (n < p_so) - return TRUE; + return true; } - return FALSE; + return false; } void update_curswant(void) @@ -384,7 +384,7 @@ void update_curswant(void) if (curwin->w_set_curswant) { validate_virtcol(); curwin->w_curswant = curwin->w_virtcol; - curwin->w_set_curswant = FALSE; + curwin->w_set_curswant = false; } } @@ -433,11 +433,11 @@ void changed_window_setting_win(win_T *wp) void set_topline(win_T *wp, linenr_T lnum) { /* go to first of folded lines */ - (void)hasFoldingWin(wp, lnum, &lnum, NULL, TRUE, NULL); + (void)hasFoldingWin(wp, lnum, &lnum, NULL, true, NULL); /* Approximate the value of w_botline */ wp->w_botline += lnum - wp->w_topline; wp->w_topline = lnum; - wp->w_topline_was_set = TRUE; + wp->w_topline_was_set = true; wp->w_topfill = 0; wp->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_TOPLINE); /* Don't set VALID_TOPLINE here, 'scrolloff' needs to be checked. */ @@ -506,7 +506,7 @@ void approximate_botline_win(win_T *wp) } /* - * Return TRUE if curwin->w_wrow and curwin->w_wcol are valid. + * Return true if curwin->w_wrow and curwin->w_wcol are valid. */ int cursor_valid(void) { @@ -523,7 +523,7 @@ void validate_cursor(void) { check_cursor_moved(curwin); if ((curwin->w_valid & (VALID_WCOL|VALID_WROW)) != (VALID_WCOL|VALID_WROW)) - curs_columns(TRUE); + curs_columns(true); } /* @@ -535,7 +535,7 @@ static void curs_rows(win_T *wp) linenr_T lnum; int i; int all_invalid; - int valid; + bool valid; long fold_count; /* Check if wp->w_lines[].wl_size is invalid */ @@ -545,7 +545,7 @@ static void curs_rows(win_T *wp) i = 0; wp->w_cline_row = 0; for (lnum = wp->w_topline; lnum < wp->w_cursor.lnum; ++i) { - valid = FALSE; + 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 */ @@ -556,7 +556,7 @@ static void curs_rows(win_T *wp) || wp->w_lines[i].wl_lastlnum < wp->w_cursor.lnum || wp->w_buffer->b_mod_top > wp->w_lines[i].wl_lastlnum + 1) - valid = TRUE; + valid = true; } else if (wp->w_lines[i].wl_lnum > lnum) --i; /* hold at inserted lines */ } @@ -576,10 +576,10 @@ static void curs_rows(win_T *wp) break; ++wp->w_cline_row; } else if (lnum == wp->w_topline) - wp->w_cline_row += plines_win_nofill(wp, lnum++, TRUE) + wp->w_cline_row += plines_win_nofill(wp, lnum++, true) + wp->w_topfill; else - wp->w_cline_row += plines_win(wp, lnum++, TRUE); + wp->w_cline_row += plines_win(wp, lnum++, true); } } @@ -592,19 +592,19 @@ static void curs_rows(win_T *wp) || wp->w_lines[i].wl_lnum != wp->w_cursor.lnum))) { if (wp->w_cursor.lnum == wp->w_topline) wp->w_cline_height = plines_win_nofill(wp, wp->w_cursor.lnum, - TRUE) + wp->w_topfill; + true) + wp->w_topfill; else - wp->w_cline_height = plines_win(wp, wp->w_cursor.lnum, TRUE); + wp->w_cline_height = plines_win(wp, wp->w_cursor.lnum, true); wp->w_cline_folded = hasFoldingWin(wp, wp->w_cursor.lnum, - NULL, NULL, TRUE, NULL); + NULL, NULL, true, NULL); } else if (i > wp->w_lines_valid) { /* a line that is too long to fit on the last screen line */ wp->w_cline_height = 0; wp->w_cline_folded = hasFoldingWin(wp, wp->w_cursor.lnum, - NULL, NULL, TRUE, NULL); + NULL, NULL, true, NULL); } else { wp->w_cline_height = wp->w_lines[i].wl_size; - wp->w_cline_folded = wp->w_lines[i].wl_folded == TRUE; + wp->w_cline_folded = wp->w_lines[i].wl_folded; } } @@ -727,7 +727,7 @@ int curwin_col_off2(void) */ void curs_columns ( - int may_scroll /* when TRUE, may scroll horizontally */ + int may_scroll /* when true, may scroll horizontally */ ) { int diff; @@ -864,7 +864,7 @@ curs_columns ( || curwin->w_wrow + p_so >= curwin->w_height) && (p_lines = plines_win_nofill - (curwin, curwin->w_cursor.lnum, FALSE)) + (curwin, curwin->w_cursor.lnum, false)) - 1 >= curwin->w_height)) && curwin->w_height != 0 && curwin->w_cursor.lnum == curwin->w_topline @@ -883,7 +883,7 @@ curs_columns ( /* Compute last display line of the buffer line that we want at the * bottom of the window. */ if (p_lines == 0) - p_lines = plines_win(curwin, curwin->w_cursor.lnum, FALSE); + p_lines = plines_win(curwin, curwin->w_cursor.lnum, false); --p_lines; if (p_lines > curwin->w_wrow + p_so) { assert(p_so <= INT_MAX); @@ -934,9 +934,9 @@ curs_columns ( extra = ((int)prev_skipcol - (int)curwin->w_skipcol) / width; if (extra > 0) - win_ins_lines(curwin, 0, extra, FALSE, FALSE); + win_ins_lines(curwin, 0, extra, false, false); else if (extra < 0) - win_del_lines(curwin, 0, -extra, FALSE, FALSE); + win_del_lines(curwin, 0, -extra, false, false); } else curwin->w_skipcol = 0; if (prev_skipcol != curwin->w_skipcol) @@ -957,12 +957,12 @@ curs_columns ( void scrolldown ( long line_count, - int byfold /* TRUE: count a closed fold as one line */ + int byfold /* true: count a closed fold as one line */ ) { int done = 0; /* total # of physical lines done */ int wrow; - int moved = FALSE; + bool moved = false; linenr_T first; @@ -1023,7 +1023,7 @@ scrolldown ( wrow -= plines(curwin->w_cursor.lnum--); curwin->w_valid &= ~(VALID_WROW|VALID_WCOL|VALID_CHEIGHT|VALID_CROW|VALID_VIRTCOL); - moved = TRUE; + moved = true; } if (moved) { /* Move cursor to first line of closed fold. */ @@ -1038,7 +1038,7 @@ scrolldown ( void scrollup ( long line_count, - int byfold /* TRUE: count a closed fold as one line */ + int byfold /* true: count a closed fold as one line */ ) { linenr_T lnum; @@ -1096,13 +1096,13 @@ scrollup ( void check_topfill ( win_T *wp, - bool down /* when TRUE scroll down when not enough space */ + 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); + 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; @@ -1304,7 +1304,7 @@ static void topline_botline(lineoff_T *lp) /* * Recompute topline to put the cursor at the top of the window. * Scroll at least "min_scroll" lines. - * If "always" is TRUE, always set topline (for "zt"). + * If "always" is true, always set topline (for "zt"). */ void scroll_cursor_top(int min_scroll, int always) { @@ -1391,10 +1391,10 @@ void scroll_cursor_top(int min_scroll, int always) * in a small window. */ if (used > curwin->w_height) - scroll_cursor_halfway(FALSE); + scroll_cursor_halfway(false); else { /* - * If "always" is FALSE, only adjust topline to a lower value, higher + * If "always" is false, only adjust topline to a lower value, higher * value may happen with wrapping lines */ if (new_topline < curwin->w_topline || always) @@ -1443,7 +1443,7 @@ void set_empty_rows(win_T *wp, int used) /* * Recompute topline to put the cursor at the bottom of the window. * Scroll at least "min_scroll" lines. - * If "set_topbot" is TRUE, set topline and botline first (for "zb"). + * If "set_topbot" is true, set topline and botline first (for "zb"). * This is messy stuff!!! */ void scroll_cursor_bot(int min_scroll, int set_topbot) @@ -1599,9 +1599,9 @@ void scroll_cursor_bot(int min_scroll, int set_topbot) * Otherwise put it at 1/2 of the screen. */ if (line_count >= curwin->w_height && line_count > min_scroll) - scroll_cursor_halfway(FALSE); + scroll_cursor_halfway(false); else - scrollup(line_count, TRUE); + scrollup(line_count, true); /* * If topline didn't change we need to restore w_botline and w_empty_rows @@ -1618,7 +1618,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot) /// Recompute topline to put the cursor halfway across the window /// -/// @param atend if TRUE, also put the cursor halfway to the end of the file. +/// @param atend if true, also put the cursor halfway to the end of the file. /// void scroll_cursor_halfway(int atend) { @@ -1947,7 +1947,7 @@ int onepage(int dir, long count) * wrapping lines and non-wrapping line). */ if (retval == OK && dir == FORWARD && check_top_offset()) { - scroll_cursor_top(1, FALSE); + scroll_cursor_top(1, false); if (curwin->w_topline <= old_topline && old_topline < curbuf->b_ml.ml_line_count) { curwin->w_topline = old_topline + 1; @@ -2221,7 +2221,7 @@ 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; + restart_edit = true; check_cursor(); restart_edit = restart_edit_save; /* Correct cursor for multi-byte character. */ @@ -2232,7 +2232,7 @@ void do_check_cursorbind(void) /* Only scroll when 'scrollbind' hasn't done this. */ if (!curwin->w_p_scb) update_topline(); - curwin->w_redr_status = TRUE; + curwin->w_redr_status = true; } } -- cgit From 23acaf8940ca55d6fb4f180c2b78c2f90bfafa8a Mon Sep 17 00:00:00 2001 From: Nicolas Cornu Date: Tue, 8 Sep 2015 13:51:36 +0200 Subject: Scope variables in move.c --- src/nvim/move.c | 259 ++++++++++++++++++++++---------------------------------- 1 file changed, 102 insertions(+), 157 deletions(-) (limited to 'src/nvim/move.c') 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(); -- cgit