vim: src/move.c comparison

comparison src/move.c @ 18931:80b40bd5ec1a v8.2.0026

patch 8.2.0026: still some /* */ comments Commit: https://github.com/vim/vim/commit/85a2002adb0eda9a9309c2fab4a79edaa91fb834 Author: Bram Moolenaar <Bram@vim.org> Date: Sat Dec 21 18:25:54 2019 +0100 patch 8.2.0026: still some /* */ comments Problem: Still some /* */ comments. Solution: Convert to // comments.

author	Bram Moolenaar <Bram@vim.org>
date	Sat, 21 Dec 2019 18:30:05 +0100
parents	fb2d26bc8ca1
children	9e428147e4ee

comparison

equal deleted inserted replaced

-:394f34c5c683
+:80b40bd5ec1a
 static int check_top_offset(void);
 static void curs_rows(win_T *wp);
 typedef struct
 {
-linenr_T	    lnum;	/* line number */
+linenr_T	    lnum;	// line number
 #ifdef FEAT_DIFF
-int		    fill;	/* filler lines */
+int		    fill;	// filler lines
 #endif
-int		    height;	/* height of added line */
+int		    height;	// height of added line
 } lineoff_T;
 static void topline_back(lineoff_T *lp);
 static void botline_forw(lineoff_T *lp);
 #ifdef FEAT_FOLDING
 	lnum = last;
 #endif
 }
-/* wp->w_botline is the line that is just below the window */
+// wp->w_botline is the line that is just below the window
 wp->w_botline = lnum;
 wp->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
 set_empty_rows(wp, done);
 }
 int		check_topline = FALSE;
 int		check_botline = FALSE;
 long        *so_ptr = curwin->w_p_so >= 0 ? &curwin->w_p_so : &p_so;
 int		save_so = *so_ptr;
-/* If there is no valid screen and when the window height is zero just use
+// If there is no valid screen and when the window height is zero just use
-* the cursor line. */
+// the cursor line.
 if (!screen_valid(TRUE) || curwin->w_height == 0)
 {
 	curwin->w_topline = curwin->w_cursor.lnum;
 	curwin->w_botline = curwin->w_topline;
 	curwin->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
 check_cursor_moved(curwin);
 if (curwin->w_valid & VALID_TOPLINE)
 	return;
-/* When dragging with the mouse, don't scroll that quickly */
+// When dragging with the mouse, don't scroll that quickly
 if (mouse_dragging > 0)
 	*so_ptr = mouse_dragging - 1;
 old_topline = curwin->w_topline;
 #ifdef FEAT_DIFF
 #endif
 /*
 * If the buffer is empty, always set topline to 1.
 */
-if (BUFEMPTY())		/* special case - file is empty */
+if (BUFEMPTY())		// special case - file is empty
 {
 	if (curwin->w_topline != 1)
 	    redraw_later(NOT_VALID);
 	curwin->w_topline = 1;
 	curwin->w_botline = 2;
 */
 else
 {
 	if (curwin->w_topline > 1)
 	{
-	    /* If the cursor is above topline, scrolling is always needed.
+	    // If the cursor is above topline, scrolling is always needed.
-	     * If the cursor is far below topline and there is no folding,
+	    // If the cursor is far below topline and there is no folding,
-	     * scrolling down is never needed. */
+	    // scrolling down is never needed.
 	    if (curwin->w_cursor.lnum < curwin->w_topline)
 		check_topline = TRUE;
 	    else if (check_top_offset())
 		check_topline = TRUE;
 	}
 #ifdef FEAT_DIFF
-	    /* Check if there are more filler lines than allowed. */
+	    // 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;
 #endif
 		halfheight = 2;
 #ifdef FEAT_FOLDING
 	    if (hasAnyFolding(curwin))
 	    {
-		/* Count the number of logical lines between the cursor and
+		// Count the number of logical lines between the cursor and
-		 * topline + scrolloff (approximation of how much will be
+		// topline + scrolloff (approximation of how much will be
-		 * scrolled). */
+		// scrolled).
 		n = 0;
 		for (lnum = curwin->w_cursor.lnum;
-				      lnum < curwin->w_topline + *so_ptr; ++lnum)
+				    lnum < curwin->w_topline + *so_ptr; ++lnum)
 		{
 		    ++n;
-		    /* stop at end of file or when we know we are far off */
+		    // stop at end of file or when we know we are far off
 		    if (lnum >= curbuf->b_ml.ml_line_count || n >= halfheight)
 			break;
 		    (void)hasFolding(lnum, NULL, &lnum);
 		}
 	    }
 	    else
 #endif
 		n = curwin->w_topline + *so_ptr - curwin->w_cursor.lnum;
-	    /* If we weren't very close to begin with, we scroll to put the
+	    // 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
+	    // cursor in the middle of the window.  Otherwise put the cursor
-	     * near the top of the window. */
+	    // near the top of the window.
 	    if (n >= halfheight)
 		scroll_cursor_halfway(FALSE);
 	    else
 	    {
 		scroll_cursor_top(scrolljump_value(), FALSE);
 	}
 	else
 	{
 #ifdef FEAT_FOLDING
-	    /* Make sure topline is the first line of a fold. */
+	    // Make sure topline is the first line of a fold.
 	    (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
 #endif
 	    check_botline = TRUE;
 	}
 }
 #endif
 			))
 	      {
 		lineoff_T	loff;
-		/* Cursor is (a few lines) above botline, check if there are
+		// Cursor is (a few lines) above botline, check if there are
-		 * 'scrolloff' window lines below the cursor.  If not, need to
+		// 'scrolloff' window lines below the cursor.  If not, need to
-		 * scroll. */
+		// scroll.
 		n = curwin->w_empty_rows;
 		loff.lnum = curwin->w_cursor.lnum;
 #ifdef FEAT_FOLDING
-		/* In a fold go to its last line. */
+		// In a fold go to its last line.
 		(void)hasFolding(loff.lnum, NULL, &loff.lnum);
 #endif
 #ifdef FEAT_DIFF
 		loff.fill = 0;
 		n += curwin->w_filler_rows;
 		    if (n >= *so_ptr)
 			break;
 		    botline_forw(&loff);
 		}
 		if (n >= *so_ptr)
-		    /* sufficient context, no need to scroll */
+		    // sufficient context, no need to scroll
 		    check_botline = FALSE;
 	      }
 	      else
-		  /* sufficient context, no need to scroll */
+		  // sufficient context, no need to scroll
 		  check_botline = FALSE;
 	    }
 	    if (check_botline)
 	    {
 #ifdef FEAT_FOLDING
 		if (hasAnyFolding(curwin))
 		{
-		    /* Count the number of logical lines between the cursor and
+		    // Count the number of logical lines between the cursor and
-		     * botline - scrolloff (approximation of how much will be
+		    // botline - scrolloff (approximation of how much will be
-		     * scrolled). */
+		    // scrolled).
 		    line_count = 0;
 		    for (lnum = curwin->w_cursor.lnum;
-				     lnum >= curwin->w_botline - *so_ptr; --lnum)
+				   lnum >= curwin->w_botline - *so_ptr; --lnum)
 		    {
 			++line_count;
-			/* stop at end of file or when we know we are far off */
+			// stop at end of file or when we know we are far off
 			if (lnum <= 0 || line_count > curwin->w_height + 1)
 			    break;
 			(void)hasFolding(lnum, &lnum, NULL);
 		    }
 		}
 	    curwin->w_skipcol = 0;
 	    redraw_later(NOT_VALID);
 	}
 	else
 	    redraw_later(VALID);
-	/* May need to set w_skipcol when cursor in w_topline. */
+	// May need to set w_skipcol when cursor in w_topline.
 	if (curwin->w_cursor.lnum == curwin->w_topline)
 	    validate_cursor();
 }
 *so_ptr = save_so;
 	    )
 {
 	loff.lnum = curwin->w_cursor.lnum;
 #ifdef FEAT_DIFF
 	loff.fill = 0;
-	n = curwin->w_topfill;	    /* always have this context */
+	n = curwin->w_topfill;	    // always have this context
 #else
 	n = 0;
 #endif
-	/* Count the visible screen lines above the cursor line. */
+	// Count the visible screen lines above the cursor line.
 	while (n < so)
 	{
 	    topline_back(&loff);
-	    /* Stop when included a line above the window. */
+	    // Stop when included a line above the window.
 	    if (loff.lnum < curwin->w_topline
 #ifdef FEAT_DIFF
 		    || (loff.lnum == curwin->w_topline && loff.fill > 0)
 #endif
 		    )
 */
 void
 set_topline(win_T *wp, linenr_T lnum)
 {
 #ifdef FEAT_FOLDING
-/* go to first of folded lines */
+// go to first of folded lines
 (void)hasFoldingWin(wp, lnum, &lnum, NULL, TRUE, NULL);
 #endif
-/* Approximate the value of w_botline */
+// Approximate the value of w_botline
 wp->w_botline += lnum - wp->w_topline;
 wp->w_topline = lnum;
 wp->w_topline_was_set = TRUE;
 #ifdef FEAT_DIFF
 wp->w_topfill = 0;
 #endif
 wp->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_TOPLINE);
-/* Don't set VALID_TOPLINE here, 'scrolloff' needs to be checked. */
+// Don't set VALID_TOPLINE here, 'scrolloff' needs to be checked.
 redraw_later(VALID);
 }
 /*
 * Call this function when the length of the cursor line (in screen
 int		valid;
 #ifdef FEAT_FOLDING
 long	fold_count;
 #endif
-/* Check if wp->w_lines[].wl_size is invalid */
+// 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;
 wp->w_cline_row = 0;
 {
 	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 */
+		continue;		// skip changed or deleted lines
 	    if (wp->w_lines[i].wl_lnum == lnum)
 	    {
 #ifdef FEAT_FOLDING
-		/* Check for newly inserted lines below this row, in which
+		// Check for newly inserted lines below this row, in which
-		 * case we need to check for folded lines. */
+		// case we need to check for folded lines.
 		if (!wp->w_buffer->b_mod_set
 			|| wp->w_lines[i].wl_lastlnum < wp->w_cursor.lnum
 			|| wp->w_buffer->b_mod_top
 					     > wp->w_lines[i].wl_lastlnum + 1)
 #endif
 		valid = TRUE;
 	    }
 	    else if (wp->w_lines[i].wl_lnum > lnum)
-		--i;			/* hold at inserted lines */
+		--i;			// hold at inserted lines
 	}
 	if (valid
 #ifdef FEAT_DIFF
 		&& (lnum != wp->w_topline || !wp->w_p_diff)
 #endif
 		)
 	{
 #ifdef FEAT_FOLDING
 	    lnum = wp->w_lines[i].wl_lastlnum + 1;
-	    /* Cursor inside folded lines, don't count this row */
+	    // Cursor inside folded lines, don't count this row
 	    if (lnum > wp->w_cursor.lnum)
 		break;
 #else
 	    ++lnum;
 #endif
 						      NULL, NULL, TRUE, NULL);
 #endif
 	}
 	else if (i > wp->w_lines_valid)
 	{
-	    /* a line that is too long to fit on the last screen line */
+	    // a line that is too long to fit on the last screen line
 	    wp->w_cline_height = 0;
 #ifdef FEAT_FOLDING
 	    wp->w_cline_folded = hasFoldingWin(wp, wp->w_cursor.lnum,
 						      NULL, NULL, TRUE, NULL);
 #endif
 	col = curwin->w_virtcol;
 	off = curwin_col_off();
 	col += off;
 	width = curwin->w_width - off + curwin_col_off2();
-	/* long line wrapping, adjust curwin->w_wrow */
+	// long line wrapping, adjust curwin->w_wrow
 	if (curwin->w_p_wrap
 		&& col >= (colnr_T)curwin->w_width
 		&& width > 0)
-	    /* use same formula as what is used in curs_columns() */
+	    // use same formula as what is used in curs_columns()
 	    col -= ((col - curwin->w_width) / width + 1) * width;
 	if (col > (int)curwin->w_leftcol)
 	    col -= curwin->w_leftcol;
 	else
 	    col = 0;
 * Also updates curwin->w_wrow and curwin->w_cline_row.
 * Also updates curwin->w_leftcol.
 */
 void
 curs_columns(
-int		may_scroll)	/* when TRUE, may scroll horizontally */
+int		may_scroll)	// when TRUE, may scroll horizontally
 {
 int		diff;
-int		extra;		/* offset for first screen line */
+int		extra;		// offset for first screen line
 int		off_left, off_right;
 int		n;
 int		p_lines;
 int		width = 0;
 int		textwidth;
 /*
 * Compute the number of virtual columns.
 */
 #ifdef FEAT_FOLDING
 if (curwin->w_cline_folded)
-	/* In a folded line the cursor is always in the first column */
+	// In a folded line the cursor is always in the first column
 	startcol = curwin->w_virtcol = endcol = curwin->w_leftcol;
 else
 #endif
 	getvvcol(curwin, &curwin->w_cursor,
 				&startcol, &(curwin->w_virtcol), &endcol);
-/* remove '$' from change command when cursor moves onto it */
+// remove '$' from change command when cursor moves onto it
 if (startcol > dollar_vcol)
 	dollar_vcol = -1;
 extra = curwin_col_off();
 curwin->w_wcol = curwin->w_virtcol + extra;
 curwin->w_wrow = curwin->w_cline_row;
 textwidth = curwin->w_width - extra;
 if (textwidth <= 0)
 {
-	/* No room for text, put cursor in last char of window. */
+	// No room for text, put cursor in last char of window.
 	curwin->w_wcol = curwin->w_width - 1;
 	curwin->w_wrow = curwin->w_height - 1;
 }
 else if (curwin->w_p_wrap && curwin->w_width != 0)
 {
 	width = textwidth + curwin_col_off2();
-	/* long line wrapping, adjust curwin->w_wrow */
+	// long line wrapping, adjust curwin->w_wrow
 	if (curwin->w_wcol >= curwin->w_width)
 	{
 #ifdef FEAT_LINEBREAK
 	    char_u *sbr;
 #endif
-	    /* this same formula is used in validate_cursor_col() */
+	    // this same formula is used in validate_cursor_col()
 	    n = (curwin->w_wcol - curwin->w_width) / width + 1;
 	    curwin->w_wcol -= n * width;
 	    curwin->w_wrow += n;
 #ifdef FEAT_LINEBREAK
-	    /* When cursor wraps to first char of next line in Insert
+	    // When cursor wraps to first char of next line in Insert
-	     * mode, the 'showbreak' string isn't shown, backup to first
+	    // mode, the 'showbreak' string isn't shown, backup to first
-	     * column */
+	    // column
 	    sbr = get_showbreak_value(curwin);
 	    if (*sbr && *ml_get_cursor() == NUL
 				    && curwin->w_wcol == (int)vim_strsize(sbr))
 		curwin->w_wcol = 0;
 #endif
 	}
 }
-/* No line wrapping: compute curwin->w_leftcol if scrolling is on and line
+// No line wrapping: compute curwin->w_leftcol if scrolling is on and line
-* is not folded.
+// is not folded.
-* If scrolling is off, curwin->w_leftcol is assumed to be 0 */
+// If scrolling is off, curwin->w_leftcol is assumed to be 0
 else if (may_scroll
 #ifdef FEAT_FOLDING
 	    && !curwin->w_cline_folded
 #endif
 	    )
 	    if (off_left < 0)
 		diff = -off_left;
 	    else
 		diff = off_right;
-	    /* When far off or not enough room on either side, put cursor in
+	    // When far off or not enough room on either side, put cursor in
-	     * middle of window. */
+	    // middle of window.
 	    if (p_ss == 0 || diff >= textwidth / 2 || off_right >= off_left)
 		new_leftcol = curwin->w_wcol - extra - textwidth / 2;
 	    else
 	    {
 		if (diff < p_ss)
 	    if (new_leftcol < 0)
 		new_leftcol = 0;
 	    if (new_leftcol != (int)curwin->w_leftcol)
 	    {
 		curwin->w_leftcol = new_leftcol;
-		/* screen has to be redrawn with new curwin->w_leftcol */
+		// screen has to be redrawn with new curwin->w_leftcol
 		redraw_later(NOT_VALID);
 	    }
 	}
 	curwin->w_wcol -= curwin->w_leftcol;
 }
 	curwin->w_wcol -= curwin->w_leftcol;
 else
 	curwin->w_wcol = 0;
 #ifdef FEAT_DIFF
-/* Skip over filler lines.  At the top use w_topfill, there
+// Skip over filler lines.  At the top use w_topfill, there
-* may be some filler lines above the window. */
+// may be some filler lines above the window.
 if (curwin->w_cursor.lnum == curwin->w_topline)
 	curwin->w_wrow += curwin->w_topfill;
 else
 	curwin->w_wrow += diff_check_fill(curwin, curwin->w_cursor.lnum);
 #endif
 	    && curwin->w_height != 0
 	    && curwin->w_cursor.lnum == curwin->w_topline
 	    && width > 0
 	    && curwin->w_width != 0)
 {
-	/* Cursor past end of screen.  Happens with a single line that does
+	// Cursor past end of screen.  Happens with a single line that does
-	 * not fit on screen.  Find a skipcol to show the text around the
+	// not fit on screen.  Find a skipcol to show the text around the
-	 * cursor.  Avoid scrolling all the time. compute value of "extra":
+	// cursor.  Avoid scrolling all the time. compute value of "extra":
-	 * 1: Less than 'scrolloff' lines above
+	// 1: Less than 'scrolloff' lines above
-	 * 2: Less than 'scrolloff' lines below
+	// 2: Less than 'scrolloff' lines below
-	 * 3: both of them */
+	// 3: both of them
 	extra = 0;
 	if (curwin->w_skipcol + so * width > curwin->w_virtcol)
 	    extra = 1;
-	/* Compute last display line of the buffer line that we want at the
+	// Compute last display line of the buffer line that we want at the
-	 * bottom of the window. */
+	// bottom of the window.
 	if (p_lines == 0)
 	    p_lines = plines_win(curwin, curwin->w_cursor.lnum, FALSE);
 	--p_lines;
 	if (p_lines > curwin->w_wrow + so)
 	    n = curwin->w_wrow + so;
 	if ((colnr_T)n >= curwin->w_height + curwin->w_skipcol / width)
 	    extra += 2;
 	if (extra == 3 || p_lines < so * 2)
 	{
-	    /* not enough room for 'scrolloff', put cursor in the middle */
+	    // not enough room for 'scrolloff', put cursor in the middle
 	    n = curwin->w_virtcol / width;
 	    if (n > curwin->w_height / 2)
 		n -= curwin->w_height / 2;
 	    else
 		n = 0;
-	    /* don't skip more than necessary */
+	    // don't skip more than necessary
 	    if (n > p_lines - curwin->w_height + 1)
 		n = p_lines - curwin->w_height + 1;
 	    curwin->w_skipcol = n * width;
 	}
 	else if (extra == 1)
 	{
-	    /* less then 'scrolloff' lines above, decrease skipcol */
+	    // less then 'scrolloff' lines above, decrease skipcol
 	    extra = (curwin->w_skipcol + so * width - curwin->w_virtcol
 				     + width - 1) / width;
 	    if (extra > 0)
 	    {
 		if ((colnr_T)(extra * width) > curwin->w_skipcol)
 		curwin->w_skipcol -= extra * width;
 	    }
 	}
 	else if (extra == 2)
 	{
-	    /* less then 'scrolloff' lines below, increase skipcol */
+	    // less then 'scrolloff' lines below, increase skipcol
 	    endcol = (n - curwin->w_height + 1) * width;
 	    while (endcol > curwin->w_virtcol)
 		endcol -= width;
 	    if (endcol > curwin->w_skipcol)
 		curwin->w_skipcol = endcol;
 	}
 	curwin->w_wrow -= curwin->w_skipcol / width;
 	if (curwin->w_wrow >= curwin->w_height)
 	{
-	    /* small window, make sure cursor is in it */
+	    // small window, make sure cursor is in it
 	    extra = curwin->w_wrow - curwin->w_height + 1;
 	    curwin->w_skipcol += extra * width;
 	    curwin->w_wrow -= extra;
 	}
 	curwin->w_skipcol = 0;
 if (prev_skipcol != curwin->w_skipcol)
 	redraw_later(NOT_VALID);
 #ifdef FEAT_SYN_HL
-/* Redraw when w_virtcol changes and 'cursorcolumn' is set */
+// Redraw when w_virtcol changes and 'cursorcolumn' is set
 if (curwin->w_p_cuc && (curwin->w_valid & VALID_VIRTCOL) == 0
 	    && !pum_visible())
 	redraw_later(SOME_VALID);
 #endif
 * Scroll the current window down by "line_count" logical lines.  "CTRL-Y"
 */
 void
 scrolldown(
 long	line_count,
-int		byfold UNUSED)	/* TRUE: count a closed fold as one line */
+int		byfold UNUSED)	// TRUE: count a closed fold as one line
 {
-long	done = 0;	/* total # of physical lines done */
+long	done = 0;	// total # of physical lines done
 int		wrow;
 int		moved = FALSE;
 #ifdef FEAT_FOLDING
 linenr_T	first;
-/* Make sure w_topline is at the first of a sequence of folded lines. */
+// Make sure w_topline is at the first of a sequence of folded lines.
 (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
 #endif
-validate_cursor();		/* w_wrow needs to be valid */
+validate_cursor();		// w_wrow needs to be valid
 while (line_count-- > 0)
 {
 #ifdef FEAT_DIFF
 	if (curwin->w_topfill < diff_check(curwin, curwin->w_topline)
 		&& curwin->w_topfill < curwin->w_height - 1)
 	    --curwin->w_topline;
 #ifdef FEAT_DIFF
 	    curwin->w_topfill = 0;
 #endif
 #ifdef FEAT_FOLDING
-	    /* A sequence of folded lines only counts for one logical line */
+	    // A sequence of folded lines only counts for one logical line
 	    if (hasFolding(curwin->w_topline, &first, NULL))
 	    {
 		++done;
 		if (!byfold)
 		    line_count -= curwin->w_topline - first - 1;
 	    }
 	    else
 #endif
 		done += PLINES_NOFILL(curwin->w_topline);
 	}
-	--curwin->w_botline;		/* approximate w_botline */
+	--curwin->w_botline;		// approximate w_botline
 	invalidate_botline();
 }
-curwin->w_wrow += done;		/* keep w_wrow updated */
+curwin->w_wrow += done;		// keep w_wrow updated
-curwin->w_cline_row += done;	/* keep w_cline_row updated */
+curwin->w_cline_row += done;	// keep w_cline_row updated
 #ifdef FEAT_DIFF
 if (curwin->w_cursor.lnum == curwin->w_topline)
 	curwin->w_cline_row = 0;
 check_topfill(curwin, TRUE);
 	moved = TRUE;
 }
 if (moved)
 {
 #ifdef FEAT_FOLDING
-	/* Move cursor to first line of closed fold. */
+	// Move cursor to first line of closed fold.
 	foldAdjustCursor();
 #endif
 	coladvance(curwin->w_curswant);
 }
 }
 * Scroll the current window up by "line_count" logical lines.  "CTRL-E"
 */
 void
 scrollup(
 long	line_count,
-int		byfold UNUSED)	/* TRUE: count a closed fold as one line */
+int		byfold UNUSED)	// TRUE: count a closed fold as one line
 {
 #if defined(FEAT_FOLDING) || defined(FEAT_DIFF)
 linenr_T	lnum;
 if (
 # ifdef FEAT_DIFF
 	    curwin->w_p_diff
 # endif
 	    )
 {
-	/* count each sequence of folded lines as one logical line */
+	// count each sequence of folded lines as one logical line
 	lnum = curwin->w_topline;
 	while (line_count--)
 	{
 # ifdef FEAT_DIFF
 	    if (curwin->w_topfill > 0)
 # ifdef FEAT_DIFF
 		curwin->w_topfill = diff_check_fill(curwin, lnum);
 # endif
 	    }
 	}
-	/* approximate w_botline */
+	// approximate w_botline
 	curwin->w_botline += lnum - curwin->w_topline;
 	curwin->w_topline = lnum;
 }
 else
 #endif
 {
 	curwin->w_topline += line_count;
-	curwin->w_botline += line_count;	/* approximate w_botline */
+	curwin->w_botline += line_count;	// approximate w_botline
 }
 if (curwin->w_topline > curbuf->b_ml.ml_line_count)
 	curwin->w_topline = curbuf->b_ml.ml_line_count;
 if (curwin->w_botline > curbuf->b_ml.ml_line_count + 1)
 check_topfill(curwin, FALSE);
 #endif
 #ifdef FEAT_FOLDING
 if (hasAnyFolding(curwin))
-	/* Make sure w_topline is at the first of a sequence of folded lines. */
+	// Make sure w_topline is at the first of a sequence of folded lines.
 	(void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
 #endif
 curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE);
 if (curwin->w_cursor.lnum < curwin->w_topline)
 * Don't end up with too many filler lines in the window.
 */
 void
 check_topfill(
 win_T	*wp,
-int		down)	/* when TRUE scroll down when not enough space */
+int		down)	// when TRUE scroll down when not enough space
 {
 int		n;
 if (wp->w_topfill > 0)
 {
 	    && !can_fill
 #endif
 	    )
 	return;
-validate_cursor();	    /* w_wrow needs to be valid */
+validate_cursor();	    // w_wrow needs to be valid
 /*
 * Compute the row number of the last row of the cursor line
 * and make sure it doesn't go off the screen. Make sure the cursor
 * doesn't go past 'scrolloff' lines from the screen end.
 	--curwin->w_topline;
 #endif
 #ifdef FEAT_FOLDING
 	(void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
 #endif
-	--curwin->w_botline;	    /* approximate w_botline */
+	--curwin->w_botline;	    // approximate w_botline
 	curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE);
 }
 }
 /*
 	    && curwin->w_topfill == 0
 #endif
 	    )
 	return;
-validate_cursor();	    /* w_wrow needs to be valid */
+validate_cursor();	    // w_wrow needs to be valid
 /*
 * Compute the row number of the first row of the cursor line
 * and make sure it doesn't go off the screen. Make sure the cursor
 * doesn't go before 'scrolloff' lines from the screen start.
 #ifdef FEAT_FOLDING
 	    (void)hasFolding(curwin->w_topline, NULL, &curwin->w_topline);
 #endif
 	    ++curwin->w_topline;
 	}
-	++curwin->w_botline;		/* approximate w_botline */
+	++curwin->w_botline;		// approximate w_botline
 	curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE);
 }
 }
 /*
 topline_back(lineoff_T *lp)
 {
 #ifdef FEAT_DIFF
 if (lp->fill < diff_check_fill(curwin, lp->lnum))
 {
-	/* Add a filler line. */
+	// Add a filler line.
 	++lp->fill;
 	lp->height = 1;
 }
 else
 #endif
 	if (lp->lnum < 1)
 	    lp->height = MAXCOL;
 	else
 #ifdef FEAT_FOLDING
 	    if (hasFolding(lp->lnum, &lp->lnum, NULL))
-	    /* Add a closed fold */
+	    // Add a closed fold
 	    lp->height = 1;
 	else
 #endif
 	    lp->height = PLINES_NOFILL(lp->lnum);
 }
 botline_forw(lineoff_T *lp)
 {
 #ifdef FEAT_DIFF
 if (lp->fill < diff_check_fill(curwin, lp->lnum + 1))
 {
-	/* Add a filler line. */
+	// Add a filler line.
 	++lp->fill;
 	lp->height = 1;
 }
 else
 #endif
 	if (lp->lnum > curbuf->b_ml.ml_line_count)
 	    lp->height = MAXCOL;
 	else
 #ifdef FEAT_FOLDING
 	    if (hasFolding(lp->lnum, NULL, &lp->lnum))
-	    /* Add a closed fold */
+	    // Add a closed fold
 	    lp->height = 1;
 	else
 #endif
 	    lp->height = PLINES_NOFILL(lp->lnum);
 }
 {
 int		scrolled = 0;
 int		extra = 0;
 int		used;
 int		i;
-linenr_T	top;		/* just above displayed lines */
+linenr_T	top;		// just above displayed lines
-linenr_T	bot;		/* just below displayed lines */
+linenr_T	bot;		// just below displayed lines
 linenr_T	old_topline = curwin->w_topline;
 #ifdef FEAT_DIFF
 linenr_T	old_topfill = curwin->w_topfill;
 #endif
 linenr_T	new_topline;
 * - (part of) the cursor line is moved off the screen or
 * - moved at least 'scrolljump' lines and
 * - at least 'scrolloff' lines above and below the cursor
 */
 validate_cheight();
-used = curwin->w_cline_height; /* includes filler lines above */
+used = curwin->w_cline_height; // includes filler lines above
 if (curwin->w_cursor.lnum < curwin->w_topline)
 	scrolled = used;
 #ifdef FEAT_FOLDING
 if (hasFolding(curwin->w_cursor.lnum, &top, &bot))
 	bot = curwin->w_cursor.lnum + 1;
 }
 new_topline = top + 1;
 #ifdef FEAT_DIFF
-/* "used" already contains the number of filler lines above, don't add it
+// "used" already contains the number of filler lines above, don't add it
-* again.
+// again.
-* Hide filler lines above cursor line by adding them to "extra". */
+// Hide filler lines above cursor line by adding them to "extra".
 extra += diff_check_fill(curwin, curwin->w_cursor.lnum);
 #endif
 /*
 * Check if the lines from "top" to "bot" fit in the window.  If they do,
 */
 while (top > 0)
 {
 #ifdef FEAT_FOLDING
 	if (hasFolding(top, &top, NULL))
-	    /* count one logical line for a sequence of folded lines */
+	    // count one logical line for a sequence of folded lines
 	    i = 1;
 	else
 #endif
 	    i = PLINES_NOFILL(top);
 	used += i;
 	if (extra + i <= off && bot < curbuf->b_ml.ml_line_count)
 	{
 #ifdef FEAT_FOLDING
 	    if (hasFolding(bot, NULL, &bot))
-		/* count one logical line for a sequence of folded lines */
+		// count one logical line for a sequence of folded lines
 		++used;
 	    else
 #endif
 		used += plines(bot);
 	}
 {
 #ifdef FEAT_DIFF
 wp->w_filler_rows = 0;
 #endif
 if (used == 0)
-	wp->w_empty_rows = 0;	/* single line that doesn't fit */
+	wp->w_empty_rows = 0;	// single line that doesn't fit
 else
 {
 	wp->w_empty_rows = wp->w_height - used;
 #ifdef FEAT_DIFF
 	if (wp->w_botline <= wp->w_buffer->b_ml.ml_line_count)
 int		fill_below_window;
 #endif
 linenr_T	old_botline = curwin->w_botline;
 linenr_T	old_valid = curwin->w_valid;
 int		old_empty_rows = curwin->w_empty_rows;
-linenr_T	cln;		    /* Cursor Line Number */
+linenr_T	cln;		    // Cursor Line Number
 long        so = get_scrolloff_value();
 cln = curwin->w_cursor.lnum;
 if (set_topbot)
 {
 	    curwin->w_valid &= ~(VALID_WROW|VALID_CROW);
 }
 else
 	validate_botline();
-/* The lines of the cursor line itself are always used. */
+// The lines of the cursor line itself are always used.
 #ifdef FEAT_DIFF
 used = plines_nofill(cln);
 #else
 validate_cheight();
 used = curwin->w_cline_height;
 #endif
-/* If the cursor is below botline, we will at least scroll by the height
+// If the cursor is below botline, we will at least scroll by the height
-* of the cursor line.  Correct for empty lines, which are really part of
+// of the cursor line.  Correct for empty lines, which are really part of
-* botline. */
+// botline.
 if (cln >= curwin->w_botline)
 {
 	scrolled = used;
 	if (cln == curwin->w_botline)
 	    scrolled -= curwin->w_empty_rows;
 						      - curwin->w_filler_rows;
 #endif
 while (loff.lnum > 1)
 {
-	/* Stop when scrolled nothing or at least "min_scroll", found "extra"
+	// Stop when scrolled nothing or at least "min_scroll", found "extra"
-	 * context for 'scrolloff' and counted all lines below the window. */
+	// context for 'scrolloff' and counted all lines below the window.
 	if ((((scrolled <= 0 || scrolled >= min_scroll)
 		    && extra >= (mouse_dragging > 0 ? mouse_dragging - 1 : so))
 		    || boff.lnum + 1 > curbuf->b_ml.ml_line_count)
 		&& loff.lnum <= curwin->w_botline
 #ifdef FEAT_DIFF
 		    || loff.fill >= fill_below_window)
 #endif
 		)
 	    break;
-	/* Add one line above */
+	// Add one line above
 	topline_back(&loff);
 	if (loff.height == MAXCOL)
 	    used = MAXCOL;
 	else
 	    used += loff.height;
 		&& (loff.lnum > curwin->w_botline
 		    || loff.fill <= fill_below_window)
 #endif
 		)
 	{
-	    /* Count screen lines that are below the window. */
+	    // Count screen lines that are below the window.
 	    scrolled += loff.height;
 	    if (loff.lnum == curwin->w_botline
 #ifdef FEAT_DIFF
 			    && loff.fill == 0
 #endif
 		scrolled -= curwin->w_empty_rows;
 	}
 	if (boff.lnum < curbuf->b_ml.ml_line_count)
 	{
-	    /* Add one line below */
+	    // Add one line below
 	    botline_forw(&boff);
 	    used += boff.height;
 	    if (used > curwin->w_height)
 		break;
 	    if (extra < ( mouse_dragging > 0 ? mouse_dragging - 1 : so)
 			|| (boff.lnum + 1 == curwin->w_botline
 			    && boff.fill > curwin->w_filler_rows)
 #endif
 		   )
 		{
-		    /* Count screen lines that are below the window. */
+		    // Count screen lines that are below the window.
 		    scrolled += boff.height;
 		    if (boff.lnum == curwin->w_botline
 #ifdef FEAT_DIFF
 			    && boff.fill == 0
 #endif
 		}
 	    }
 	}
 }
-/* curwin->w_empty_rows is larger, no need to scroll */
+// curwin->w_empty_rows is larger, no need to scroll
 if (scrolled <= 0)
 	line_count = 0;
-/* more than a screenfull, don't scroll but redraw */
+// more than a screenfull, don't scroll but redraw
 else if (used > curwin->w_height)
 	line_count = used;
-/* scroll minimal number of lines */
+// scroll minimal number of lines
 else
 {
 	line_count = 0;
 #ifdef FEAT_DIFF
 	boff.fill = curwin->w_topfill;
 	{
 	    botline_forw(&boff);
 	    i += boff.height;
 	    ++line_count;
 	}
-	if (i < scrolled)	/* below curwin->w_botline, don't scroll */
+	if (i < scrolled)	// below curwin->w_botline, don't scroll
 	    line_count = 9999;
 }
 /*
 * Scroll up if the cursor is off the bottom of the screen a bit.
 used = plines(loff.lnum);
 #endif
 topline = loff.lnum;
 while (topline > 1)
 {
-	if (below <= above)	    /* add a line below the cursor first */
+	if (below <= above)	    // add a line below the cursor first
 	{
 	    if (boff.lnum < curbuf->b_ml.ml_line_count)
 	    {
 		botline_forw(&boff);
 		used += boff.height;
 		    break;
 		below += boff.height;
 	    }
 	    else
 	    {
-		++below;	    /* count a "~" line */
+		++below;	    // count a "~" line
 		if (atend)
 		    ++used;
 	    }
 	}
-	if (below > above)	    /* add a line above the cursor */
+	if (below > above)	    // add a line above the cursor
 	{
 	    topline_back(&loff);
 	    if (loff.height == MAXCOL)
 		used = MAXCOL;
 	    else
 * When called topline must be valid!
 */
 void
 cursor_correct(void)
 {
-int		above = 0;	    /* screen lines above topline */
+int		above = 0;	    // screen lines above topline
 linenr_T	topline;
-int		below = 0;	    /* screen lines below botline */
+int		below = 0;	    // screen lines below botline
 linenr_T	botline;
 int		above_wanted, below_wanted;
-linenr_T	cln;		    /* Cursor Line Number */
+linenr_T	cln;		    // Cursor Line Number
 int		max_off;
 long        so = get_scrolloff_value();
 /*
 * How many lines we would like to have above/below the cursor depends on
 * - the lines from the top is past the lines from the bottom
 */
 topline = curwin->w_topline;
 botline = curwin->w_botline - 1;
 #ifdef FEAT_DIFF
-/* count filler lines as context */
+// count filler lines as context
 above = curwin->w_topfill;
 below = curwin->w_filler_rows;
 #endif
 while ((above < above_wanted || below < below_wanted) && topline < botline)
 {
 		++above;
 	    else
 #endif
 		above += PLINES_NOFILL(topline);
 #ifdef FEAT_DIFF
-	    /* Count filler lines below this line as context. */
+	    // Count filler lines below this line as context.
 	    if (topline < botline)
 		above += diff_check_fill(curwin, topline + 1);
 #endif
 	    ++topline;
 	}
 int		retval = OK;
 lineoff_T	loff;
 linenr_T	old_topline = curwin->w_topline;
 long        so = get_scrolloff_value();
-if (curbuf->b_ml.ml_line_count == 1)    /* nothing to do */
+if (curbuf->b_ml.ml_line_count == 1)    // nothing to do
 {
 	beep_flush();
 	return FAIL;
 }
 #endif
 	if (dir == FORWARD)
 	{
 	    if (ONE_WINDOW && p_window > 0 && p_window < Rows - 1)
 	    {
-		/* Vi compatible scrolling */
+		// Vi compatible scrolling
 		if (p_window <= 2)
 		    ++curwin->w_topline;
 		else
 		    curwin->w_topline += p_window - 2;
 		if (curwin->w_topline > curbuf->b_ml.ml_line_count)
 		    curwin->w_topline = curbuf->b_ml.ml_line_count;
 		curwin->w_cursor.lnum = curwin->w_topline;
 	    }
 	    else if (curwin->w_botline > curbuf->b_ml.ml_line_count)
 	    {
-		/* at end of file */
+		// at end of file
 		curwin->w_topline = curbuf->b_ml.ml_line_count;
 #ifdef FEAT_DIFF
 		curwin->w_topfill = 0;
 #endif
 		curwin->w_valid &= ~(VALID_WROW|VALID_CROW);
 	    }
 	    else
 	    {
-		/* For the overlap, start with the line just below the window
+		// For the overlap, start with the line just below the window
-		 * and go upwards. */
+		// and go upwards.
 		loff.lnum = curwin->w_botline;
 #ifdef FEAT_DIFF
 		loff.fill = diff_check_fill(curwin, loff.lnum)
 						      - curwin->w_filler_rows;
 #endif
 		curwin->w_cursor.lnum = curwin->w_topline;
 		curwin->w_valid &= ~(VALID_WCOL|VALID_CHEIGHT|VALID_WROW|
 				   VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
 	    }
 	}
-	else	/* dir == BACKWARDS */
+	else	// dir == BACKWARDS
 	{
 #ifdef FEAT_DIFF
 	    if (curwin->w_topline == 1)
 	    {
-		/* Include max number of filler lines */
+		// Include max number of filler lines
 		max_topfill();
 		continue;
 	    }
 #endif
 	    if (ONE_WINDOW && p_window > 0 && p_window < Rows - 1)
 	    {
-		/* Vi compatible scrolling (sort of) */
+		// Vi compatible scrolling (sort of)
 		if (p_window <= 2)
 		    --curwin->w_topline;
 		else
 		    curwin->w_topline -= p_window - 2;
 		if (curwin->w_topline < 1)
 		if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
 		    curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
 		continue;
 	    }
-	    /* Find the line at the top of the window that is going to be the
+	    // Find the line at the top of the window that is going to be the
-	     * line at the bottom of the window.  Make sure this results in
+	    // line at the bottom of the window.  Make sure this results in
-	     * the same line as before doing CTRL-F. */
+	    // the same line as before doing CTRL-F.
 	    loff.lnum = curwin->w_topline - 1;
 #ifdef FEAT_DIFF
 	    loff.fill = diff_check_fill(curwin, loff.lnum + 1)
 							  - curwin->w_topfill;
 #endif
 		botline_topline(&loff);
 #endif
 	    }
 	    curwin->w_cursor.lnum = loff.lnum;
-	    /* Find the line just above the new topline to get the right line
+	    // Find the line just above the new topline to get the right line
-	     * at the bottom of the window. */
+	    // at the bottom of the window.
 	    n = 0;
 	    while (n <= curwin->w_height && loff.lnum >= 1)
 	    {
 		topline_back(&loff);
 		if (loff.height == MAXCOL)
 		    n = MAXCOL;
 		else
 		    n += loff.height;
 	    }
-	    if (loff.lnum < 1)			/* at begin of file */
+	    if (loff.lnum < 1)			// at begin of file
 	    {
 		curwin->w_topline = 1;
 #ifdef FEAT_DIFF
 		max_topfill();
 #endif
 		curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE);
 	    }
 	    else
 	    {
-		/* Go two lines forward again. */
+		// Go two lines forward again.
 #ifdef FEAT_DIFF
 		topline_botline(&loff);
 #endif
 		botline_forw(&loff);
 		botline_forw(&loff);
 #ifdef FEAT_DIFF
 		botline_topline(&loff);
 #endif
 #ifdef FEAT_FOLDING
-		/* We're at the wrong end of a fold now. */
+		// We're at the wrong end of a fold now.
 		(void)hasFolding(loff.lnum, &loff.lnum, NULL);
 #endif
-		/* Always scroll at least one line.  Avoid getting stuck on
+		// Always scroll at least one line.  Avoid getting stuck on
-		 * very long lines. */
+		// very long lines.
 		if (loff.lnum >= curwin->w_topline
 #ifdef FEAT_DIFF
 			&& (loff.lnum > curwin->w_topline
 			    || loff.fill >= curwin->w_topfill)
 #endif
 			)
 		{
 #ifdef FEAT_DIFF
-		    /* First try using the maximum number of filler lines.  If
+		    // First try using the maximum number of filler lines.  If
-		     * that's not enough, backup one line. */
+		    // that's not enough, backup one line.
 		    loff.fill = curwin->w_topfill;
 		    if (curwin->w_topfill < diff_check_fill(curwin,
 							   curwin->w_topline))
 			max_topfill();
 		    if (curwin->w_topfill == loff.fill)
 #else
 lp->height = plines(lp->lnum);
 #endif
 h1 = lp->height;
 if (h1 > min_height)
-	return;		/* no overlap */
+	return;		// no overlap
 loff0 = *lp;
 if (dir > 0)
 	botline_forw(lp);
 else
 	topline_back(lp);
 h2 = lp->height;
 if (h2 == MAXCOL || h2 + h1 > min_height)
 {
-	*lp = loff0;	/* no overlap */
+	*lp = loff0;	// no overlap
 	return;
 }
 loff1 = *lp;
 if (dir > 0)
 else
 	topline_back(lp);
 h3 = lp->height;
 if (h3 == MAXCOL || h3 + h2 > min_height)
 {
-	*lp = loff0;	/* no overlap */
+	*lp = loff0;	// no overlap
 	return;
 }
 loff2 = *lp;
 if (dir > 0)
 	botline_forw(lp);
 else
 	topline_back(lp);
 h4 = lp->height;
 if (h4 == MAXCOL || h4 + h3 + h2 > min_height || h3 + h2 + h1 > min_height)
-	*lp = loff1;	/* 1 line overlap */
+	*lp = loff1;	// 1 line overlap
 else
-	*lp = loff2;	/* 2 lines overlap */
+	*lp = loff2;	// 2 lines overlap
 return;
 }
 /*
 * Scroll 'scroll' lines up or down.
 # endif
 		curwin->w_cursor.lnum -= n;
 	}
 }
 # ifdef FEAT_FOLDING
-/* Move cursor to first line of closed fold. */
+// Move cursor to first line of closed fold.
 foldAdjustCursor();
 # endif
 #ifdef FEAT_DIFF
 check_topfill(curwin, !flag);
 #endif
 */
 VIsual_select = VIsual_active = 0;
 FOR_ALL_WINDOWS(curwin)
 {
 	curbuf = curwin->w_buffer;
-	/* skip original window  and windows with 'noscrollbind' */
+	// skip original window  and windows with 'noscrollbind'
 	if (curwin != old_curwin && curwin->w_p_crb)
 	{
 # ifdef FEAT_DIFF
 	    if (curwin->w_p_diff)
 		curwin->w_cursor.lnum =
 	    curwin->w_cursor.col = col;
 	    curwin->w_cursor.coladd = coladd;
 	    curwin->w_curswant = curswant;
 	    curwin->w_set_curswant = set_curswant;
-	    /* Make sure the cursor is in a valid position.  Temporarily set
+	    // Make sure the cursor is in a valid position.  Temporarily set
-	     * "restart_edit" to allow the cursor to be beyond the EOL. */
+	    // "restart_edit" to allow the cursor to be beyond the EOL.
 	    restart_edit_save = restart_edit;
 	    restart_edit = TRUE;
 	    check_cursor();
 # ifdef FEAT_SYN_HL
 	    if (curwin->w_p_cul || curwin->w_p_cuc)
 		validate_cursor();
 # endif
 	    restart_edit = restart_edit_save;
-	    /* Correct cursor for multi-byte character. */
+	    // Correct cursor for multi-byte character.
 	    if (has_mbyte)
 		mb_adjust_cursor();
 	    redraw_later(VALID);
-	    /* Only scroll when 'scrollbind' hasn't done this. */
+	    // Only scroll when 'scrollbind' hasn't done this.
 	    if (!curwin->w_p_scb)
 		update_topline();
 	    curwin->w_redr_status = TRUE;
 	}
 }

Mercurial > vim

comparison src/move.c @ 18931:80b40bd5ec1a v8.2.0026