vim: src/ops.c comparison

comparison src/ops.c @ 18808:7982f65d8f54 v8.1.2392

patch 8.1.2392: using old C style comments Commit: https://github.com/vim/vim/commit/6e0ce171e19d0118ecd7c2b16e2a1bd50aa76013 Author: Bram Moolenaar <Bram@vim.org> Date: Thu Dec 5 20:12:41 2019 +0100 patch 8.1.2392: using old C style comments Problem: Using old C style comments. Solution: Use // comments where appropriate.

author	Bram Moolenaar <Bram@vim.org>
date	Thu, 05 Dec 2019 20:15:04 +0100
parents	49b78d6465e5
children	f9e41ffd3539

comparison

equal deleted inserted replaced

-:7e28c71af59a
+:7982f65d8f54
 int
 get_op_type(int char1, int char2)
 {
 int		i;
-if (char1 == 'r')		/* ignore second character */
+if (char1 == 'r')		// ignore second character
 	return OP_REPLACE;
-if (char1 == '~')		/* when tilde is an operator */
+if (char1 == '~')		// when tilde is an operator
 	return OP_TILDE;
-if (char1 == 'g' && char2 == Ctrl_A)	/* add */
+if (char1 == 'g' && char2 == Ctrl_A)	// add
 	return OP_NR_ADD;
-if (char1 == 'g' && char2 == Ctrl_X)	/* subtract */
+if (char1 == 'g' && char2 == Ctrl_X)	// subtract
 	return OP_NR_SUB;
 for (i = 0; ; ++i)
 {
 	if (opchars[i][0] == char1 && opchars[i][1] == char2)
 	    break;
 	block_col = curwin->w_cursor.col;
 for (i = oap->line_count; --i >= 0; )
 {
 	first_char = *ml_get_curline();
-	if (first_char == NUL)				/* empty line */
+	if (first_char == NUL)				// empty line
 	    curwin->w_cursor.col = 0;
 	else if (oap->block_mode)
 	    shift_block(oap, amount);
 	else
-	    /* Move the line right if it doesn't start with '#', 'smartindent'
+	    // Move the line right if it doesn't start with '#', 'smartindent'
-	     * isn't set or 'cindent' isn't set or '#' isn't in 'cino'. */
+	    // isn't set or 'cindent' isn't set or '#' isn't in 'cino'.
 #if defined(FEAT_SMARTINDENT) || defined(FEAT_CINDENT)
 	    if (first_char != '#' || !preprocs_left())
 #endif
 	    shift_line(oap->op_type == OP_LSHIFT, p_sr, amount, FALSE);
 	++curwin->w_cursor.lnum;
 if (oap->block_mode)
 {
 	curwin->w_cursor.lnum = oap->start.lnum;
 	curwin->w_cursor.col = block_col;
 }
-else if (curs_top)	    /* put cursor on first line, for ">>" */
+else if (curs_top)	    // put cursor on first line, for ">>"
 {
 	curwin->w_cursor.lnum = oap->start.lnum;
-	beginline(BL_SOL | BL_FIX);   /* shift_line() may have set cursor.col */
+	beginline(BL_SOL | BL_FIX);   // shift_line() may have set cursor.col
 }
 else
-	--curwin->w_cursor.lnum;	/* put cursor on last line, for ":>" */
+	--curwin->w_cursor.lnum;	// put cursor on last line, for ":>"
 #ifdef FEAT_FOLDING
-/* The cursor line is not in a closed fold */
+// The cursor line is not in a closed fold
 foldOpenCursor();
 #endif
 if (oap->line_count > p_report)
 int			i = 0, j = 0;
 int			len;
 #ifdef FEAT_RIGHTLEFT
 int			old_p_ri = p_ri;
-p_ri = 0;			/* don't want revins in indent */
+p_ri = 0;			// don't want revins in indent
 #endif
-State = INSERT;		/* don't want REPLACE for State */
+State = INSERT;		// don't want REPLACE for State
 block_prep(oap, &bd, curwin->w_cursor.lnum, TRUE);
 if (bd.is_short)
 	return;
-/* total is number of screen columns to be inserted/removed */
+// total is number of screen columns to be inserted/removed
 total = (int)((unsigned)amount * (unsigned)sw_val);
 if ((total / sw_val) != amount)
-	return; /* multiplication overflow */
+	return; // multiplication overflow
 oldp = ml_get_curline();
 if (!left)
 {
 	 *  1. Get start vcol
 	 *  2. Total ws vcols
 	 *  3. Divvy into TABs & spp
 	 *  4. Construct new string
 	 */
-	total += bd.pre_whitesp; /* all virtual WS upto & incl a split TAB */
+	total += bd.pre_whitesp; // all virtual WS upto & incl a split TAB
 	ws_vcol = bd.start_vcol - bd.pre_whitesp;
 	if (bd.startspaces)
 	{
 	    if (has_mbyte)
 	    {
 	    else
 		++bd.textstart;
 	}
 	for ( ; VIM_ISWHITE(*bd.textstart); )
 	{
-	    /* TODO: is passing bd.textstart for start of the line OK? */
+	    // TODO: is passing bd.textstart for start of the line OK?
 	    incr = lbr_chartabsize_adv(bd.textstart, &bd.textstart,
 						    (colnr_T)(bd.start_vcol));
 	    total += incr;
 	    bd.start_vcol += incr;
 	}
-	/* OK, now total=all the VWS reqd, and textstart points at the 1st
+	// OK, now total=all the VWS reqd, and textstart points at the 1st
-	 * non-ws char in the block. */
+	// non-ws char in the block.
 #ifdef FEAT_VARTABS
 	if (!curbuf->b_p_et)
 	    tabstop_fromto(ws_vcol, ws_vcol + total,
 					ts_val, curbuf->b_p_vts_array, &i, &j);
 	else
 	    j = total;
 #else
 	if (!curbuf->b_p_et)
-	    i = ((ws_vcol % ts_val) + total) / ts_val; /* number of tabs */
+	    i = ((ws_vcol % ts_val) + total) / ts_val; // number of tabs
 	if (i)
-	    j = ((ws_vcol % ts_val) + total) % ts_val; /* number of spp */
+	    j = ((ws_vcol % ts_val) + total) % ts_val; // number of spp
 	else
 	    j = total;
 #endif
-	/* if we're splitting a TAB, allow for it */
+	// if we're splitting a TAB, allow for it
 	bd.textcol -= bd.pre_whitesp_c - (bd.startspaces != 0);
 	len = (int)STRLEN(bd.textstart) + 1;
 	newp = alloc(bd.textcol + i + j + len);
 	if (newp == NULL)
 	    return;
 	vim_memset(newp, NUL, (size_t)(bd.textcol + i + j + len));
 	mch_memmove(newp, oldp, (size_t)bd.textcol);
 	vim_memset(newp + bd.textcol, TAB, (size_t)i);
 	vim_memset(newp + bd.textcol + i, ' ', (size_t)j);
-	/* the end */
+	// the end
 	mch_memmove(newp + bd.textcol + i + j, bd.textstart, (size_t)len);
 }
-else /* left */
+else // left
 {
-	colnr_T	    destination_col;	/* column to which text in block will
+	colnr_T	    destination_col;	// column to which text in block will
-					   be shifted */
+					// be shifted
-	char_u	    *verbatim_copy_end;	/* end of the part of the line which is
+	char_u	    *verbatim_copy_end;	// end of the part of the line which is
-					   copied verbatim */
+					// copied verbatim
-	colnr_T	    verbatim_copy_width;/* the (displayed) width of this part
+	colnr_T	    verbatim_copy_width;// the (displayed) width of this part
-					   of line */
+					// of line
-	unsigned    fill;		/* nr of spaces that replace a TAB */
+	unsigned    fill;		// nr of spaces that replace a TAB
-	unsigned    new_line_len;	/* the length of the line after the
+	unsigned    new_line_len;	// the length of the line after the
-					   block shift */
+					// block shift
 	size_t	    block_space_width;
 	size_t	    shift_amount;
 	char_u	    *non_white = bd.textstart;
 	colnr_T	    non_white_col;
 	 * number. Also, let's calculate the width of all the whitespace
 	 * characters that are displayed in the block and precede the searched
 	 * non-whitespace character.
 	 */
-	/* If "bd.startspaces" is set, "bd.textstart" points to the character,
+	// If "bd.startspaces" is set, "bd.textstart" points to the character,
-	 * the part of which is displayed at the block's beginning. Let's start
+	// the part of which is displayed at the block's beginning. Let's start
-	 * searching from the next character. */
+	// searching from the next character.
 	if (bd.startspaces)
 	    MB_PTR_ADV(non_white);
-	/* The character's column is in "bd.start_vcol".  */
+	// The character's column is in "bd.start_vcol".
 	non_white_col = bd.start_vcol;
 	while (VIM_ISWHITE(*non_white))
 	{
 	    incr = lbr_chartabsize_adv(bd.textstart, &non_white, non_white_col);
 	    non_white_col += incr;
 	}
 	block_space_width = non_white_col - oap->start_vcol;
-	/* We will shift by "total" or "block_space_width", whichever is less.
+	// We will shift by "total" or "block_space_width", whichever is less.
-	 */
 	shift_amount = (block_space_width < (size_t)total
 					 ? block_space_width : (size_t)total);
-	/* The column to which we will shift the text.  */
+	// The column to which we will shift the text.
 	destination_col = (colnr_T)(non_white_col - shift_amount);
-	/* Now let's find out how much of the beginning of the line we can
+	// Now let's find out how much of the beginning of the line we can
-	 * reuse without modification.  */
+	// reuse without modification.
 	verbatim_copy_end = bd.textstart;
 	verbatim_copy_width = bd.start_vcol;
-	/* If "bd.startspaces" is set, "bd.textstart" points to the character
+	// If "bd.startspaces" is set, "bd.textstart" points to the character
-	 * preceding the block. We have to subtract its width to obtain its
+	// preceding the block. We have to subtract its width to obtain its
-	 * column number.  */
+	// column number.
 	if (bd.startspaces)
 	    verbatim_copy_width -= bd.start_char_vcols;
 	while (verbatim_copy_width < destination_col)
 	{
 	    char_u *line = verbatim_copy_end;
-	    /* TODO: is passing verbatim_copy_end for start of the line OK? */
+	    // TODO: is passing verbatim_copy_end for start of the line OK?
 	    incr = lbr_chartabsize(line, verbatim_copy_end,
 							 verbatim_copy_width);
 	    if (verbatim_copy_width + incr > destination_col)
 		break;
 	    verbatim_copy_width += incr;
 	    MB_PTR_ADV(verbatim_copy_end);
 	}
-	/* If "destination_col" is different from the width of the initial
+	// If "destination_col" is different from the width of the initial
-	 * part of the line that will be copied, it means we encountered a tab
+	// part of the line that will be copied, it means we encountered a tab
-	 * character, which we will have to partly replace with spaces.  */
+	// character, which we will have to partly replace with spaces.
 	fill = destination_col - verbatim_copy_width;
-	/* The replacement line will consist of:
+	// The replacement line will consist of:
-	 * - the beginning of the original line up to "verbatim_copy_end",
+	// - the beginning of the original line up to "verbatim_copy_end",
-	 * - "fill" number of spaces,
+	// - "fill" number of spaces,
-	 * - the rest of the line, pointed to by non_white.  */
+	// - the rest of the line, pointed to by non_white.
 	new_line_len = (unsigned)(verbatim_copy_end - oldp)
 		       + fill
 		       + (unsigned)STRLEN(non_white) + 1;
 	newp = alloc(new_line_len);
 	    return;
 	mch_memmove(newp, oldp, (size_t)(verbatim_copy_end - oldp));
 	vim_memset(newp + (verbatim_copy_end - oldp), ' ', (size_t)fill);
 	STRMOVE(newp + (verbatim_copy_end - oldp) + fill, non_white);
 }
-/* replace the line */
+// replace the line
 ml_replace(curwin->w_cursor.lnum, newp, FALSE);
 changed_bytes(curwin->w_cursor.lnum, (colnr_T)bd.textcol);
 State = oldstate;
 curwin->w_cursor.col = oldcol;
 #ifdef FEAT_RIGHTLEFT
 char_u		*s,
 int			b_insert,
 struct block_def	*bdp)
 {
 int		ts_val;
-int		count = 0;	/* extra spaces to replace a cut TAB */
+int		count = 0;	// extra spaces to replace a cut TAB
-int		spaces = 0;	/* non-zero if cutting a TAB */
+int		spaces = 0;	// non-zero if cutting a TAB
-colnr_T	offset;		/* pointer along new line */
+colnr_T	offset;		// pointer along new line
-unsigned	s_len;		/* STRLEN(s) */
+unsigned	s_len;		// STRLEN(s)
-char_u	*newp, *oldp;	/* new, old lines */
+char_u	*newp, *oldp;	// new, old lines
-linenr_T	lnum;		/* loop var */
+linenr_T	lnum;		// loop var
 int		oldstate = State;
-State = INSERT;		/* don't want REPLACE for State */
+State = INSERT;		// don't want REPLACE for State
 s_len = (unsigned)STRLEN(s);
 for (lnum = oap->start.lnum + 1; lnum <= oap->end.lnum; lnum++)
 {
 	block_prep(oap, bdp, lnum, TRUE);
 	if (bdp->is_short && b_insert)
-	    continue;	/* OP_INSERT, line ends before block start */
+	    continue;	// OP_INSERT, line ends before block start
 	oldp = ml_get(lnum);
 	if (b_insert)
 	{
 	    ts_val = bdp->start_char_vcols;
 	    spaces = bdp->startspaces;
 	    if (spaces != 0)
-		count = ts_val - 1; /* we're cutting a TAB */
+		count = ts_val - 1; // we're cutting a TAB
 	    offset = bdp->textcol;
 	}
-	else /* append */
+	else // append
 	{
 	    ts_val = bdp->end_char_vcols;
-	    if (!bdp->is_short) /* spaces = padding after block */
+	    if (!bdp->is_short) // spaces = padding after block
 	    {
 		spaces = (bdp->endspaces ? ts_val - bdp->endspaces : 0);
 		if (spaces != 0)
-		    count = ts_val - 1; /* we're cutting a TAB */
+		    count = ts_val - 1; // we're cutting a TAB
 		offset = bdp->textcol + bdp->textlen - (spaces != 0);
 	    }
-	    else /* spaces = padding to block edge */
+	    else // spaces = padding to block edge
 	    {
-		/* if $ used, just append to EOL (ie spaces==0) */
+		// if $ used, just append to EOL (ie spaces==0)
 		if (!bdp->is_MAX)
 		    spaces = (oap->end_vcol - bdp->end_vcol) + 1;
 		count = spaces;
 		offset = bdp->textcol + bdp->textlen;
 	    }
 	if (has_mbyte && spaces > 0)
 	{
 	    int off;
-	    /* Avoid starting halfway a multi-byte character. */
+	    // Avoid starting halfway a multi-byte character.
 	    if (b_insert)
 	    {
 		off = (*mb_head_off)(oldp, oldp + offset + spaces);
 	    }
 	    else
 	newp = alloc(STRLEN(oldp) + s_len + count + 1);
 	if (newp == NULL)
 	    continue;
-	/* copy up to shifted part */
+	// copy up to shifted part
 	mch_memmove(newp, oldp, (size_t)(offset));
 	oldp += offset;
-	/* insert pre-padding */
+	// insert pre-padding
 	vim_memset(newp + offset, ' ', (size_t)spaces);
-	/* copy the new text */
+	// copy the new text
 	mch_memmove(newp + offset + spaces, s, (size_t)s_len);
 	offset += s_len;
 	if (spaces && !bdp->is_short)
 	{
-	    /* insert post-padding */
+	    // insert post-padding
 	    vim_memset(newp + offset + spaces, ' ', (size_t)(ts_val - spaces));
-	    /* We're splitting a TAB, don't copy it. */
+	    // We're splitting a TAB, don't copy it.
 	    oldp++;
-	    /* We allowed for that TAB, remember this now */
+	    // We allowed for that TAB, remember this now
 	    count++;
 	}
 	if (spaces > 0)
 	    offset += count;
 	ml_replace(lnum, newp, FALSE);
 	if (lnum == oap->end.lnum)
 	{
-	    /* Set "']" mark to the end of the block instead of the end of
+	    // Set "']" mark to the end of the block instead of the end of
-	     * the insert in the first line.  */
+	    // the insert in the first line.
 	    curbuf->b_op_end.lnum = oap->end.lnum;
 	    curbuf->b_op_end.col = offset;
 	}
-} /* for all lnum */
+} // for all lnum
 changed_lines(oap->start.lnum + 1, 0, oap->end.lnum + 1, 0L);
 State = oldstate;
 }
 int		c;
 char_u	*start;
 while (*arg != NUL)
 {
-	/* Stuff a sequence of normal ASCII characters, that's fast.  Also
+	// Stuff a sequence of normal ASCII characters, that's fast.  Also
-	 * stuff K_SPECIAL to get the effect of a special key when "literally"
+	// stuff K_SPECIAL to get the effect of a special key when "literally"
-	 * is TRUE. */
+	// is TRUE.
 	start = arg;
 	while ((*arg >= ' '
 #ifndef EBCDIC
-		    && *arg < DEL /* EBCDIC: chars above space are normal */
+		    && *arg < DEL // EBCDIC: chars above space are normal
 #endif
 		    )
 		|| (*arg == K_SPECIAL && !literally))
 	    ++arg;
 	if (arg > start)
 	    stuffReadbuffLen(start, (long)(arg - start));
-	/* stuff a single special character */
+	// stuff a single special character
 	if (*arg != NUL)
 	{
 	    if (has_mbyte)
 		c = mb_cptr2char_adv(&arg);
 	    else
 char_u		*newp, *oldp;
 struct block_def	bd;
 linenr_T		old_lcount = curbuf->b_ml.ml_line_count;
 int			did_yank = FALSE;
-if (curbuf->b_ml.ml_flags & ML_EMPTY)	    /* nothing to do */
+if (curbuf->b_ml.ml_flags & ML_EMPTY)	    // nothing to do
 	return OK;
-/* Nothing to delete, return here.	Do prepare undo, for op_change(). */
+// Nothing to delete, return here.	Do prepare undo, for op_change().
 if (oap->empty)
 	return u_save_cursor();
 if (!curbuf->b_p_ma)
 {
 	/*
 	 * It's an error to operate on an empty region, when 'E' included in
 	 * 'cpoptions' (Vi compatible).
 	 */
 	if (virtual_op)
-	    /* Virtual editing: Nothing gets deleted, but we set the '[ and ']
+	    // Virtual editing: Nothing gets deleted, but we set the '[ and ']
-	     * marks as if it happened. */
+	    // marks as if it happened.
 	    goto setmarks;
 	if (vim_strchr(p_cpo, CPO_EMPTYREGION) != NULL)
 	    beep_flush();
 	return OK;
 }
 */
 if (oap->regname != '_')
 {
 	if (oap->regname != 0)
 	{
-	    /* check for read-only register */
+	    // check for read-only register
 	    if (!valid_yank_reg(oap->regname, TRUE))
 	    {
 		beep_flush();
 		return OK;
 	    }
-	    get_yank_register(oap->regname, TRUE); /* yank into specif'd reg. */
+	    get_yank_register(oap->regname, TRUE); // yank into specif'd reg.
-	    if (op_yank(oap, TRUE, FALSE) == OK)   /* yank without message */
+	    if (op_yank(oap, TRUE, FALSE) == OK)   // yank without message
 		did_yank = TRUE;
 	}
 	/*
 	 * Put deleted text into register 1 and shift number registers if the
 	    shift_delete_registers();
 	    if (op_yank(oap, TRUE, FALSE) == OK)
 		did_yank = TRUE;
 	}
-	/* Yank into small delete register when no named register specified
+	// Yank into small delete register when no named register specified
-	 * and the delete is within one line. */
+	// and the delete is within one line.
 	if ((
 #ifdef FEAT_CLIPBOARD
 	    ((clip_unnamed & CLIP_UNNAMED) && oap->regname == '*') ||
 	    ((clip_unnamed & CLIP_UNNAMED_PLUS) && oap->regname == '+') ||
 #endif
 	 */
 	if (!did_yank)
 	{
 	    int msg_silent_save = msg_silent;
-	    msg_silent = 0;	/* must display the prompt */
+	    msg_silent = 0;	// must display the prompt
 	    n = ask_yesno((char_u *)_("cannot yank; delete anyway"), TRUE);
 	    msg_silent = msg_silent_save;
 	    if (n != 'y')
 	    {
 		emsg(_(e_abort));
 	    return FAIL;
 	for (lnum = curwin->w_cursor.lnum; lnum <= oap->end.lnum; ++lnum)
 	{
 	    block_prep(oap, &bd, lnum, TRUE);
-	    if (bd.textlen == 0)	/* nothing to delete */
+	    if (bd.textlen == 0)	// nothing to delete
 		continue;
-	    /* Adjust cursor position for tab replaced by spaces and 'lbr'. */
+	    // Adjust cursor position for tab replaced by spaces and 'lbr'.
 	    if (lnum == curwin->w_cursor.lnum)
 	    {
 		curwin->w_cursor.col = bd.textcol + bd.startspaces;
 		curwin->w_cursor.coladd = 0;
 	    }
 	    n = bd.textlen - bd.startspaces - bd.endspaces;
 	    oldp = ml_get(lnum);
 	    newp = alloc(STRLEN(oldp) + 1 - n);
 	    if (newp == NULL)
 		continue;
-	    /* copy up to deleted part */
+	    // copy up to deleted part
 	    mch_memmove(newp, oldp, (size_t)bd.textcol);
-	    /* insert spaces */
+	    // insert spaces
 	    vim_memset(newp + bd.textcol, ' ',
 				     (size_t)(bd.startspaces + bd.endspaces));
-	    /* copy the part after the deleted part */
+	    // copy the part after the deleted part
 	    oldp += bd.textcol + bd.textlen;
 	    STRMOVE(newp + bd.textcol + bd.startspaces + bd.endspaces, oldp);
-	    /* replace the line */
+	    // replace the line
 	    ml_replace(lnum, newp, FALSE);
 #ifdef FEAT_PROP_POPUP
 	    if (curbuf->b_has_textprop && n != 0)
 		adjust_prop_columns(lnum, bd.textcol, -n, 0);
 	}
 	check_cursor_col();
 	changed_lines(curwin->w_cursor.lnum, curwin->w_cursor.col,
 						       oap->end.lnum + 1, 0L);
-	oap->line_count = 0;	    /* no lines deleted */
+	oap->line_count = 0;	    // no lines deleted
 }
 else if (oap->motion_type == MLINE)
 {
 	if (oap->op_type == OP_CHANGE)
 	{
-	    /* Delete the lines except the first one.  Temporarily move the
+	    // Delete the lines except the first one.  Temporarily move the
-	     * cursor to the next line.  Save the current line number, if the
+	    // cursor to the next line.  Save the current line number, if the
-	     * last line is deleted it may be changed.
+	    // last line is deleted it may be changed.
-	     */
 	    if (oap->line_count > 1)
 	    {
 		lnum = curwin->w_cursor.lnum;
 		++curwin->w_cursor.lnum;
 		del_lines((long)(oap->line_count - 1), TRUE);
 		curwin->w_cursor.lnum = lnum;
 	    }
 	    if (u_save_cursor() == FAIL)
 		return FAIL;
-	    if (curbuf->b_p_ai)		    /* don't delete indent */
+	    if (curbuf->b_p_ai)		    // don't delete indent
 	    {
-		beginline(BL_WHITE);	    /* cursor on first non-white */
+		beginline(BL_WHITE);	    // cursor on first non-white
-		did_ai = TRUE;		    /* delete the indent when ESC hit */
+		did_ai = TRUE;		    // delete the indent when ESC hit
 		ai_col = curwin->w_cursor.col;
 	    }
 	    else
-		beginline(0);		    /* cursor in column 0 */
+		beginline(0);		    // cursor in column 0
-	    truncate_line(FALSE);   /* delete the rest of the line */
+	    truncate_line(FALSE);   // delete the rest of the line
-				    /* leave cursor past last char in line */
+				    // leave cursor past last char in line
 	    if (oap->line_count > 1)
-		u_clearline();	    /* "U" command not possible after "2cc" */
+		u_clearline();	    // "U" command not possible after "2cc"
 	}
 	else
 	{
 	    del_lines(oap->line_count, TRUE);
 	    beginline(BL_WHITE | BL_FIX);
-	    u_clearline();	/* "U" command not possible after "dd" */
+	    u_clearline();	// "U" command not possible after "dd"
 	}
 }
 else
 {
 	if (virtual_op)
 	{
 	    int		endcol = 0;
-	    /* For virtualedit: break the tabs that are partly included. */
+	    // For virtualedit: break the tabs that are partly included.
 	    if (gchar_pos(&oap->start) == '\t')
 	    {
-		if (u_save_cursor() == FAIL)	/* save first line for undo */
+		if (u_save_cursor() == FAIL)	// save first line for undo
 		    return FAIL;
 		if (oap->line_count == 1)
 		    endcol = getviscol2(oap->end.col, oap->end.coladd);
 		coladvance_force(getviscol2(oap->start.col, oap->start.coladd));
 		oap->start = curwin->w_cursor;
 		    oap->end.coladd = curwin->w_cursor.coladd;
 		    curwin->w_cursor = oap->start;
 		}
 	    }
-	    /* Break a tab only when it's included in the area. */
+	    // Break a tab only when it's included in the area.
 	    if (gchar_pos(&oap->end) == '\t'
 				     && (int)oap->end.coladd < oap->inclusive)
 	    {
-		/* save last line for undo */
+		// save last line for undo
 		if (u_save((linenr_T)(oap->end.lnum - 1),
 				       (linenr_T)(oap->end.lnum + 1)) == FAIL)
 		    return FAIL;
 		curwin->w_cursor = oap->end;
 		coladvance_force(getviscol2(oap->end.col, oap->end.coladd));
 	    }
 	    if (has_mbyte)
 		mb_adjust_opend(oap);
 	}
-	if (oap->line_count == 1)	/* delete characters within one line */
+	if (oap->line_count == 1)	// delete characters within one line
 	{
-	    if (u_save_cursor() == FAIL)	/* save line for undo */
+	    if (u_save_cursor() == FAIL)	// save line for undo
 		return FAIL;
-	    /* if 'cpoptions' contains '$', display '$' at end of change */
+	    // if 'cpoptions' contains '$', display '$' at end of change
 	    if (       vim_strchr(p_cpo, CPO_DOLLAR) != NULL
 		    && oap->op_type == OP_CHANGE
 		    && oap->end.lnum == curwin->w_cursor.lnum
 		    && !oap->is_VIsual)
 		display_dollar(oap->end.col - !oap->inclusive);
 	    n = oap->end.col - oap->start.col + 1 - !oap->inclusive;
 	    if (virtual_op)
 	    {
-		/* fix up things for virtualedit-delete:
+		// fix up things for virtualedit-delete:
-		 * break the tabs which are going to get in our way
+		// break the tabs which are going to get in our way
-		 */
 		char_u		*curline = ml_get_curline();
 		int		len = (int)STRLEN(curline);
 		if (oap->end.coladd != 0
 			&& (int)oap->end.col >= len - 1
 			&& !(oap->start.coladd && (int)oap->end.col >= len - 1))
 		    n++;
-		/* Delete at least one char (e.g, when on a control char). */
+		// Delete at least one char (e.g, when on a control char).
 		if (n == 0 && oap->start.coladd != oap->end.coladd)
 		    n = 1;
-		/* When deleted a char in the line, reset coladd. */
+		// When deleted a char in the line, reset coladd.
 		if (gchar_cursor() != NUL)
 		    curwin->w_cursor.coladd = 0;
 	    }
 	    (void)del_bytes((long)n, !virtual_op,
 			    oap->op_type == OP_DELETE && !oap->is_VIsual);
 	}
-	else				/* delete characters between lines */
+	else				// delete characters between lines
 	{
 	    pos_T   curpos;
-	    /* save deleted and changed lines for undo */
+	    // save deleted and changed lines for undo
 	    if (u_save((linenr_T)(curwin->w_cursor.lnum - 1),
 		 (linenr_T)(curwin->w_cursor.lnum + oap->line_count)) == FAIL)
 		return FAIL;
-	    truncate_line(TRUE);	/* delete from cursor to end of line */
+	    truncate_line(TRUE);	// delete from cursor to end of line
-	    curpos = curwin->w_cursor;	/* remember curwin->w_cursor */
+	    curpos = curwin->w_cursor;	// remember curwin->w_cursor
 	    ++curwin->w_cursor.lnum;
 	    del_lines((long)(oap->line_count - 2), FALSE);
-	    /* delete from start of line until op_end */
+	    // delete from start of line until op_end
 	    n = (oap->end.col + 1 - !oap->inclusive);
 	    curwin->w_cursor.col = 0;
 	    (void)del_bytes((long)n, !virtual_op,
 			    oap->op_type == OP_DELETE && !oap->is_VIsual);
-	    curwin->w_cursor = curpos;	/* restore curwin->w_cursor */
+	    curwin->w_cursor = curpos;	// restore curwin->w_cursor
 	    (void)do_join(2, FALSE, FALSE, FALSE, FALSE);
 	}
 }
 msgmore(curbuf->b_ml.ml_line_count - old_lcount);
 int n = State;
 State = REPLACE;
 ins_char(c);
 State = n;
-/* Backup to the replaced character. */
+// Backup to the replaced character.
 dec_cursor();
 }
 /*
 * Replace a whole area with one character.
 struct block_def	bd;
 char_u		*after_p = NULL;
 int			had_ctrl_v_cr = FALSE;
 if ((curbuf->b_ml.ml_flags & ML_EMPTY ) || oap->empty)
-	return OK;	    /* nothing to do */
+	return OK;	    // nothing to do
 if (c == REPLACE_CR_NCHAR)
 {
 	had_ctrl_v_cr = TRUE;
 	c = CAR;
 if (oap->block_mode)
 {
 	bd.is_MAX = (curwin->w_curswant == MAXCOL);
 	for ( ; curwin->w_cursor.lnum <= oap->end.lnum; ++curwin->w_cursor.lnum)
 	{
-	    curwin->w_cursor.col = 0;  /* make sure cursor position is valid */
+	    curwin->w_cursor.col = 0;  // make sure cursor position is valid
 	    block_prep(oap, &bd, curwin->w_cursor.lnum, TRUE);
 	    if (bd.textlen == 0 && (!virtual_op || bd.is_MAX))
-		continue;	    /* nothing to replace */
+		continue;	    // nothing to replace
-	    /* n == number of extra chars required
+	    // n == number of extra chars required
-	     * If we split a TAB, it may be replaced by several characters.
+	    // If we split a TAB, it may be replaced by several characters.
-	     * Thus the number of characters may increase!
+	    // Thus the number of characters may increase!
-	     */
+	    // If the range starts in virtual space, count the initial
-	    /* If the range starts in virtual space, count the initial
+	    // coladd offset as part of "startspaces"
-	     * coladd offset as part of "startspaces" */
 	    if (virtual_op && bd.is_short && *bd.textstart == NUL)
 	    {
 		pos_T vpos;
 		vpos.lnum = curwin->w_cursor.lnum;
 		getvpos(&vpos, oap->start_vcol);
 		bd.startspaces += vpos.coladd;
 		n = bd.startspaces;
 	    }
 	    else
-		/* allow for pre spaces */
+		// allow for pre spaces
 		n = (bd.startspaces ? bd.start_char_vcols - 1 : 0);
-	    /* allow for post spp */
+	    // allow for post spp
 	    n += (bd.endspaces
 		    && !bd.is_oneChar
 		    && bd.end_char_vcols > 0) ? bd.end_char_vcols - 1 : 0;
-	    /* Figure out how many characters to replace. */
+	    // Figure out how many characters to replace.
 	    numc = oap->end_vcol - oap->start_vcol + 1;
 	    if (bd.is_short && (!virtual_op || bd.is_MAX))
 		numc -= (oap->end_vcol - bd.end_vcol) + 1;
-	    /* A double-wide character can be replaced only up to half the
+	    // A double-wide character can be replaced only up to half the
-	     * times. */
+	    // times.
 	    if ((*mb_char2cells)(c) > 1)
 	    {
 		if ((numc & 1) && !bd.is_short)
 		{
 		    ++bd.endspaces;
 		    ++n;
 		}
 		numc = numc / 2;
 	    }
-	    /* Compute bytes needed, move character count to num_chars. */
+	    // Compute bytes needed, move character count to num_chars.
 	    num_chars = numc;
 	    numc *= (*mb_char2len)(c);
-	    /* oldlen includes textlen, so don't double count */
+	    // oldlen includes textlen, so don't double count
 	    n += numc - bd.textlen;
 	    oldp = ml_get_curline();
 	    oldlen = STRLEN(oldp);
 	    newp = alloc(oldlen + 1 + n);
 	    if (newp == NULL)
 		continue;
 	    vim_memset(newp, NUL, (size_t)(oldlen + 1 + n));
-	    /* copy up to deleted part */
+	    // copy up to deleted part
 	    mch_memmove(newp, oldp, (size_t)bd.textcol);
 	    oldp += bd.textcol + bd.textlen;
-	    /* insert pre-spaces */
+	    // insert pre-spaces
 	    vim_memset(newp + bd.textcol, ' ', (size_t)bd.startspaces);
-	    /* insert replacement chars CHECK FOR ALLOCATED SPACE */
+	    // insert replacement chars CHECK FOR ALLOCATED SPACE
-	    /* REPLACE_CR_NCHAR/REPLACE_NL_NCHAR is used for entering CR
+	    // REPLACE_CR_NCHAR/REPLACE_NL_NCHAR is used for entering CR
-	     * literally. */
+	    // literally.
 	    if (had_ctrl_v_cr || (c != '\r' && c != '\n'))
 	    {
 		if (has_mbyte)
 		{
 		    n = (int)STRLEN(newp);
 		}
 		else
 		    vim_memset(newp + STRLEN(newp), c, (size_t)numc);
 		if (!bd.is_short)
 		{
-		    /* insert post-spaces */
+		    // insert post-spaces
 		    vim_memset(newp + STRLEN(newp), ' ', (size_t)bd.endspaces);
-		    /* copy the part after the changed part */
+		    // copy the part after the changed part
 		    STRMOVE(newp + STRLEN(newp), oldp);
 		}
 	    }
 	    else
 	    {
-		/* Replacing with \r or \n means splitting the line. */
+		// Replacing with \r or \n means splitting the line.
 		after_p = alloc(oldlen + 1 + n - STRLEN(newp));
 		if (after_p != NULL)
 		    STRMOVE(after_p, oldp);
 	    }
-	    /* replace the line */
+	    // replace the line
 	    ml_replace(curwin->w_cursor.lnum, newp, FALSE);
 	    if (after_p != NULL)
 	    {
 		ml_append(curwin->w_cursor.lnum++, after_p, 0, FALSE);
 		appended_lines_mark(curwin->w_cursor.lnum, 1L);
 	    n = gchar_cursor();
 	    if (n != NUL)
 	    {
 		if ((*mb_char2len)(c) > 1 || (*mb_char2len)(n) > 1)
 		{
-		    /* This is slow, but it handles replacing a single-byte
+		    // This is slow, but it handles replacing a single-byte
-		     * with a multi-byte and the other way around. */
+		    // with a multi-byte and the other way around.
 		    if (curwin->w_cursor.lnum == oap->end.lnum)
 			oap->end.col += (*mb_char2len)(c) - (*mb_char2len)(n);
 		    replace_character(c);
 		}
 		else
 		    {
 			int end_vcol = 0;
 			if (curwin->w_cursor.lnum == oap->end.lnum)
 			{
-			    /* oap->end has to be recalculated when
+			    // oap->end has to be recalculated when
-			     * the tab breaks */
+			    // the tab breaks
 			    end_vcol = getviscol2(oap->end.col,
 							     oap->end.coladd);
 			}
 			coladvance_force(getviscol());
 			if (curwin->w_cursor.lnum == oap->end.lnum)
 		if (curwin->w_cursor.lnum == oap->start.lnum
 			&& oap->start.col == oap->end.col && oap->start.coladd)
 		    virtcols -= oap->start.coladd;
-		/* oap->end has been trimmed so it's effectively inclusive;
+		// oap->end has been trimmed so it's effectively inclusive;
-		 * as a result an extra +1 must be counted so we don't
+		// as a result an extra +1 must be counted so we don't
-		 * trample the NUL byte. */
+		// trample the NUL byte.
 		coladvance_force(getviscol2(oap->end.col, oap->end.coladd) + 1);
 		curwin->w_cursor.col -= (virtcols + 1);
 		for (; virtcols >= 0; virtcols--)
 		{
 if ((*mb_char2len)(c) > 1)
 		   if (inc(&curwin->w_cursor) == -1)
 		       break;
 		}
 	    }
-	    /* Advance to next character, stop at the end of the file. */
+	    // Advance to next character, stop at the end of the file.
 	    if (inc_cursor() == -1)
 		break;
 	}
 }
 check_cursor();
 changed_lines(oap->start.lnum, oap->start.col, oap->end.lnum + 1, 0L);
 if (!cmdmod.lockmarks)
 {
-	/* Set "'[" and "']" marks. */
+	// Set "'[" and "']" marks.
 	curbuf->b_op_start = oap->start;
 	curbuf->b_op_end = oap->end;
 }
 return OK;
 if (u_save((linenr_T)(oap->start.lnum - 1),
 				       (linenr_T)(oap->end.lnum + 1)) == FAIL)
 	return;
 pos = oap->start;
-if (oap->block_mode)		    /* Visual block mode */
+if (oap->block_mode)		    // Visual block mode
 {
 	for (; pos.lnum <= oap->end.lnum; ++pos.lnum)
 	{
 	    int one_change;
 #endif
 	}
 	if (did_change)
 	    changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L);
 }
-else				    /* not block mode */
+else				    // not block mode
 {
 	if (oap->motion_type == MLINE)
 	{
 	    oap->start.col = 0;
 	    pos.col = 0;
 #endif
 	}
 }
 if (!did_change && oap->is_VIsual)
-	/* No change: need to remove the Visual selection */
+	// No change: need to remove the Visual selection
 	redraw_curbuf_later(INVERTED);
 if (!cmdmod.lockmarks)
 {
 	// Set '[ and '] marks.
 {
 	if (has_mbyte)
 	{
 	    int len = (*mb_ptr2len)(ml_get_pos(pos));
-	    /* we're counting bytes, not characters */
+	    // we're counting bytes, not characters
 	    if (len > 0)
 		todo -= len - 1;
 	}
 	did_change |= swapchar(op_type, pos);
-	if (inc(pos) == -1)    /* at end of file */
+	if (inc(pos) == -1)    // at end of file
 	    break;
 }
 return did_change;
 }
 int	    c;
 int	    nc;
 c = gchar_pos(pos);
-/* Only do rot13 encoding for ASCII characters. */
+// Only do rot13 encoding for ASCII characters.
 if (c >= 0x80 && op_type == OP_ROT13)
 	return FALSE;
 if (op_type == OP_UPPER && c == 0xdf
 		      && (enc_latin1like || STRCMP(p_enc, "iso-8859-2") == 0))
 {
 	pos_T   sp = curwin->w_cursor;
-	/* Special handling of German sharp s: change to "SS". */
+	// Special handling of German sharp s: change to "SS".
 	curwin->w_cursor = *pos;
 	del_char(FALSE);
 	ins_char('S');
 	ins_char('S');
 	curwin->w_cursor = sp;
 	inc(pos);
 }
-if (enc_dbcs != 0 && c >= 0x100)	/* No lower/uppercase letter */
+if (enc_dbcs != 0 && c >= 0x100)	// No lower/uppercase letter
 	return FALSE;
 nc = c;
 if (MB_ISLOWER(c))
 {
 	if (op_type == OP_ROT13)
 	if (enc_utf8 && (c >= 0x80 || nc >= 0x80))
 	{
 	    pos_T   sp = curwin->w_cursor;
 	    curwin->w_cursor = *pos;
-	    /* don't use del_char(), it also removes composing chars */
+	    // don't use del_char(), it also removes composing chars
 	    del_bytes(utf_ptr2len(ml_get_cursor()), FALSE, FALSE);
 	    ins_char(nc);
 	    curwin->w_cursor = sp;
 	}
 	else
 colnr_T		ind_pre = 0, ind_post;
 struct block_def	bd;
 int			i;
 pos_T		t1;
-/* edit() changes this - record it for OP_APPEND */
+// edit() changes this - record it for OP_APPEND
 bd.is_MAX = (curwin->w_curswant == MAXCOL);
-/* vis block is still marked. Get rid of it now. */
+// vis block is still marked. Get rid of it now.
 curwin->w_cursor.lnum = oap->start.lnum;
 update_screen(INVERTED);
 if (oap->block_mode)
 {
-	/* When 'virtualedit' is used, need to insert the extra spaces before
+	// When 'virtualedit' is used, need to insert the extra spaces before
-	 * doing block_prep().  When only "block" is used, virtual edit is
+	// doing block_prep().  When only "block" is used, virtual edit is
-	 * already disabled, but still need it when calling
+	// already disabled, but still need it when calling
-	 * coladvance_force(). */
+	// coladvance_force().
 	if (curwin->w_cursor.coladd > 0)
 	{
 	    int		old_ve_flags = ve_flags;
 	    ve_flags = VE_ALL;
 					   ? oap->end_vcol + 1 : getviscol());
 	    if (oap->op_type == OP_APPEND)
 		--curwin->w_cursor.col;
 	    ve_flags = old_ve_flags;
 	}
-	/* Get the info about the block before entering the text */
+	// Get the info about the block before entering the text
 	block_prep(oap, &bd, oap->start.lnum, TRUE);
-	/* Get indent information */
+	// Get indent information
 	ind_pre = (colnr_T)getwhitecols_curline();
 	firstline = ml_get(oap->start.lnum) + bd.textcol;
 	if (oap->op_type == OP_APPEND)
 	    firstline += bd.textlen;
 if (oap->op_type == OP_APPEND)
 {
 	if (oap->block_mode && curwin->w_cursor.coladd == 0)
 	{
-	    /* Move the cursor to the character right of the block. */
+	    // Move the cursor to the character right of the block.
 	    curwin->w_set_curswant = TRUE;
 	    while (*ml_get_cursor() != NUL
 		    && (curwin->w_cursor.col < bd.textcol + bd.textlen))
 		++curwin->w_cursor.col;
 	    if (bd.is_short && !bd.is_MAX)
 	    {
-		/* First line was too short, make it longer and adjust the
+		// First line was too short, make it longer and adjust the
-		 * values in "bd". */
+		// values in "bd".
 		if (u_save_cursor() == FAIL)
 		    return;
 		for (i = 0; i < bd.endspaces; ++i)
 		    ins_char(' ');
 		bd.textlen += bd.endspaces;
 	else
 	{
 	    curwin->w_cursor = oap->end;
 	    check_cursor_col();
-	    /* Works just like an 'i'nsert on the next character. */
+	    // Works just like an 'i'nsert on the next character.
 	    if (!LINEEMPTY(curwin->w_cursor.lnum)
 		    && oap->start_vcol != oap->end_vcol)
 		inc_cursor();
 	}
 }
 t1 = oap->start;
 (void)edit(NUL, FALSE, (linenr_T)count1);
-/* When a tab was inserted, and the characters in front of the tab
+// When a tab was inserted, and the characters in front of the tab
-* have been converted to a tab as well, the column of the cursor
+// have been converted to a tab as well, the column of the cursor
-* might have actually been reduced, so need to adjust here. */
+// might have actually been reduced, so need to adjust here.
 if (t1.lnum == curbuf->b_op_start_orig.lnum
 	    && LT_POS(curbuf->b_op_start_orig, t1))
 	oap->start = curbuf->b_op_start_orig;
-/* If user has moved off this line, we don't know what to do, so do
+// If user has moved off this line, we don't know what to do, so do
-* nothing.
+// nothing.
-* Also don't repeat the insert when Insert mode ended with CTRL-C. */
+// Also don't repeat the insert when Insert mode ended with CTRL-C.
 if (curwin->w_cursor.lnum != oap->start.lnum || got_int)
 	return;
 if (oap->block_mode)
 {
 	struct block_def	bd2;
 	int			did_indent = FALSE;
 	size_t			len;
 	int			add;
-	/* If indent kicked in, the firstline might have changed
+	// If indent kicked in, the firstline might have changed
-	 * but only do that, if the indent actually increased. */
+	// but only do that, if the indent actually increased.
 	ind_post = (colnr_T)getwhitecols_curline();
 	if (curbuf->b_op_start.col > ind_pre && ind_post > ind_pre)
 	{
 	    bd.textcol += ind_post - ind_pre;
 	    bd.start_vcol += ind_post - ind_pre;
 	    did_indent = TRUE;
 	}
-	/* The user may have moved the cursor before inserting something, try
+	// The user may have moved the cursor before inserting something, try
-	 * to adjust the block for that.  But only do it, if the difference
+	// to adjust the block for that.  But only do it, if the difference
-	 * does not come from indent kicking in. */
+	// does not come from indent kicking in.
 	if (oap->start.lnum == curbuf->b_op_start_orig.lnum
 						  && !bd.is_MAX && !did_indent)
 	{
 	    if (oap->op_type == OP_INSERT
 		    && oap->start.col + oap->start.coladd
 					      + curbuf->b_op_start_orig.coladd)
 	    {
 		int t = getviscol2(curbuf->b_op_start_orig.col,
 					      curbuf->b_op_start_orig.coladd);
 		oap->start.col = curbuf->b_op_start_orig.col;
-		/* reset pre_textlen to the value of OP_INSERT */
+		// reset pre_textlen to the value of OP_INSERT
 		pre_textlen += bd.textlen;
 		pre_textlen -= t - oap->start_vcol;
 		oap->start_vcol = t;
 		oap->op_type = OP_INSERT;
 	    }
 		     && (ins_len = (long)STRLEN(firstline) - pre_textlen) > 0)
 	{
 	    ins_text = vim_strnsave(firstline, (int)ins_len);
 	    if (ins_text != NULL)
 	    {
-		/* block handled here */
+		// block handled here
 		if (u_save(oap->start.lnum,
 					 (linenr_T)(oap->end.lnum + 1)) == OK)
 		    block_insert(oap, ins_text, (oap->op_type == OP_INSERT),
 									 &bd);
 	if (!p_paste && curbuf->b_p_si
 # ifdef FEAT_CINDENT
 		&& !curbuf->b_p_cin
 # endif
 		)
-	    can_si = TRUE;	/* It's like opening a new line, do si */
+	    can_si = TRUE;	// It's like opening a new line, do si
 #endif
 }
-/* First delete the text in the region.  In an empty buffer only need to
+// First delete the text in the region.  In an empty buffer only need to
-* save for undo */
+// save for undo
 if (curbuf->b_ml.ml_flags & ML_EMPTY)
 {
 	if (u_save_cursor() == FAIL)
 	    return FALSE;
 }
 if ((l > curwin->w_cursor.col) && !LINEEMPTY(curwin->w_cursor.lnum)
 							 && !virtual_op)
 	inc_cursor();
-/* check for still on same line (<CR> in inserted text meaningless) */
+// check for still on same line (<CR> in inserted text meaningless)
-/* skip blank lines too */
+// skip blank lines too
 if (oap->block_mode)
 {
-	/* Add spaces before getting the current line length. */
+	// Add spaces before getting the current line length.
 	if (virtual_op && (curwin->w_cursor.coladd > 0
 						    || gchar_cursor() == NUL))
 	    coladvance_force(getviscol());
 	firstline = ml_get(oap->start.lnum);
 	pre_textlen = (long)STRLEN(firstline);
 * block.
 * Don't repeat the insert when Insert mode ended with CTRL-C.
 */
 if (oap->block_mode && oap->start.lnum != oap->end.lnum && !got_int)
 {
-	/* Auto-indenting may have changed the indent.  If the cursor was past
+	// Auto-indenting may have changed the indent.  If the cursor was past
-	 * the indent, exclude that indent change from the inserted text. */
+	// the indent, exclude that indent change from the inserted text.
 	firstline = ml_get(oap->start.lnum);
 	if (bd.textcol > (colnr_T)pre_indent)
 	{
 	    long new_indent = (long)getwhitecols(firstline);
 	}
 	ins_len = (long)STRLEN(firstline) - pre_textlen;
 	if (ins_len > 0)
 	{
-	    /* Subsequent calls to ml_get() flush the firstline data - take a
+	    // Subsequent calls to ml_get() flush the firstline data - take a
-	     * copy of the inserted text.  */
+	    // copy of the inserted text.
 	    if ((ins_text = alloc(ins_len + 1)) != NULL)
 	    {
 		vim_strncpy(ins_text, firstline + bd.textcol, (size_t)ins_len);
 		for (linenr = oap->start.lnum + 1; linenr <= oap->end.lnum;
 								     linenr++)
 		    block_prep(oap, &bd, linenr, TRUE);
 		    if (!bd.is_short || virtual_op)
 		    {
 			pos_T vpos;
-			/* If the block starts in virtual space, count the
+			// If the block starts in virtual space, count the
-			 * initial coladd offset as part of "startspaces" */
+			// initial coladd offset as part of "startspaces"
 			if (bd.is_short)
 			{
 			    vpos.lnum = linenr;
 			    (void)getvpos(&vpos, oap->start_vcol);
 			}
 			    vpos.coladd = 0;
 			oldp = ml_get(linenr);
 			newp = alloc(STRLEN(oldp) + vpos.coladd + ins_len + 1);
 			if (newp == NULL)
 			    continue;
-			/* copy up to block start */
+			// copy up to block start
 			mch_memmove(newp, oldp, (size_t)bd.textcol);
 			offset = bd.textcol;
 			vim_memset(newp + offset, ' ', (size_t)vpos.coladd);
 			offset += vpos.coladd;
 			mch_memmove(newp + offset, ins_text, (size_t)ins_len);
 if (curwin->w_cursor.col > 0
 	    && gchar_cursor() == NUL
 	    && (ve_flags & VE_ONEMORE) == 0
 	    && !(restart_edit || (State & INSERT)))
 {
-	/* Put the cursor on the last character in the line. */
+	// Put the cursor on the last character in the line.
 	dec_cursor();
 	if (ve_flags == VE_ALL)
 	{
 	    colnr_T	    scol, ecol;
-	    /* Coladd is set to the width of the last character. */
+	    // Coladd is set to the width of the last character.
 	    getvcol(curwin, &curwin->w_cursor, &scol, NULL, &ecol);
 	    curwin->w_cursor.coladd = ecol - scol + 1;
 	}
 }
 }
 int    leader_offset = get_last_leader_offset(line, &comment_flags);
 *is_comment = FALSE;
 if (leader_offset != -1)
 {
-	/* Let's check whether the line ends with an unclosed comment.
+	// Let's check whether the line ends with an unclosed comment.
-	 * If the last comment leader has COM_END in flags, there's no comment.
+	// If the last comment leader has COM_END in flags, there's no comment.
-	 */
 	while (*comment_flags)
 	{
 	    if (*comment_flags == COM_END
 		    || *comment_flags == ':')
 		break;
 lead_len = get_leader_len(line, &comment_flags, FALSE, include_space);
 if (lead_len == 0)
 	return line;
-/* Find:
+// Find:
-* - COM_END,
+// - COM_END,
-* - colon,
+// - colon,
-* whichever comes first.
+// whichever comes first.
-*/
 while (*comment_flags)
 {
 	if (*comment_flags == COM_END
 		|| *comment_flags == ':')
 	    break;
 	++comment_flags;
 }
-/* If we found a colon, it means that we are not processing a line
+// If we found a colon, it means that we are not processing a line
-* starting with a closing part of a three-part comment. That's good,
+// starting with a closing part of a three-part comment. That's good,
-* because we don't want to remove those as this would be annoying.
+// because we don't want to remove those as this would be annoying.
-*/
 if (*comment_flags == ':' || *comment_flags == NUL)
 	line += lead_len;
 return line;
 }
 {
 char_u	*curr = NULL;
 char_u      *curr_start = NULL;
 char_u	*cend;
 char_u	*newp;
-char_u	*spaces;	/* number of spaces inserted before a line */
+char_u	*spaces;	// number of spaces inserted before a line
 int		endcurr1 = NUL;
 int		endcurr2 = NUL;
-int		currsize = 0;	/* size of the current line */
+int		currsize = 0;	// size of the current line
-int		sumsize = 0;	/* size of the long new line */
+int		sumsize = 0;	// size of the long new line
 linenr_T	t;
 colnr_T	col = 0;
 int		ret = OK;
 int		*comments = NULL;
 int		remove_comments = (use_formatoptions == TRUE)
 if (save_undo && u_save((linenr_T)(curwin->w_cursor.lnum - 1),
 			    (linenr_T)(curwin->w_cursor.lnum + count)) == FAIL)
 	return FAIL;
-/* Allocate an array to store the number of spaces inserted before each
+// Allocate an array to store the number of spaces inserted before each
-* line.  We will use it to pre-compute the length of the new line and the
+// line.  We will use it to pre-compute the length of the new line and the
-* proper placement of each original line in the new one. */
+// proper placement of each original line in the new one.
 spaces = lalloc_clear(count, TRUE);
 if (spaces == NULL)
 	return FAIL;
 if (remove_comments)
 {
 for (t = 0; t < count; ++t)
 {
 	curr = curr_start = ml_get((linenr_T)(curwin->w_cursor.lnum + t));
 	if (t == 0 && setmark && !cmdmod.lockmarks)
 	{
-	    /* Set the '[ mark. */
+	    // Set the '[ mark.
 	    curwin->w_buffer->b_op_start.lnum = curwin->w_cursor.lnum;
 	    curwin->w_buffer->b_op_start.col  = (colnr_T)STRLEN(curr);
 	}
 	if (remove_comments)
 	{
-	    /* We don't want to remove the comment leader if the
+	    // We don't want to remove the comment leader if the
-	     * previous line is not a comment. */
+	    // previous line is not a comment.
 	    if (t > 0 && prev_was_comment)
 	    {
 		char_u *new_curr = skip_comment(curr, TRUE, insert_space,
 							   &prev_was_comment);
 			|| (mb_ptr2char(curr) < 0x100 && endcurr1 < 0x100))
 		    && (!has_format_option(FO_MBYTE_JOIN2)
 			|| mb_ptr2char(curr) < 0x100 || endcurr1 < 0x100)
 	       )
 	    {
-		/* don't add a space if the line is ending in a space */
+		// don't add a space if the line is ending in a space
 		if (endcurr1 == ' ')
 		    endcurr1 = endcurr2;
 		else
 		    ++spaces[t];
-		/* extra space when 'joinspaces' set and line ends in '.' */
+		// extra space when 'joinspaces' set and line ends in '.'
 		if (       p_js
 			&& (endcurr1 == '.'
 			    || (vim_strchr(p_cpo, CPO_JOINSP) == NULL
 				&& (endcurr1 == '?' || endcurr1 == '!'))))
 		    ++spaces[t];
 	    ret = FAIL;
 	    goto theend;
 	}
 }
-/* store the column position before last line */
+// store the column position before last line
 col = sumsize - currsize - spaces[count - 1];
-/* allocate the space for the new line */
+// allocate the space for the new line
 newp = alloc(sumsize + 1);
 if (newp == NULL)
 {
 	ret = FAIL;
 	goto theend;
 #endif
 	ml_replace(curwin->w_cursor.lnum, newp, FALSE);
 if (setmark && !cmdmod.lockmarks)
 {
-	/* Set the '] mark. */
+	// Set the '] mark.
 	curwin->w_buffer->b_op_end.lnum = curwin->w_cursor.lnum;
 	curwin->w_buffer->b_op_end.col  = (colnr_T)sumsize;
 }
-/* Only report the change in the first line here, del_lines() will report
+// Only report the change in the first line here, del_lines() will report
-* the deleted line. */
+// the deleted line.
 changed_lines(curwin->w_cursor.lnum, currsize,
 					       curwin->w_cursor.lnum + 1, 0L);
 /*
 * Delete following lines. To do this we move the cursor there
 * briefly, and then move it back. After del_lines() the cursor may
 * Implementation of the format operator 'gq'.
 */
 static void
 op_format(
 oparg_T	*oap,
-int		keep_cursor)		/* keep cursor on same text char */
+int		keep_cursor)		// keep cursor on same text char
 {
 long	old_line_count = curbuf->b_ml.ml_line_count;
-/* Place the cursor where the "gq" or "gw" command was given, so that "u"
+// Place the cursor where the "gq" or "gw" command was given, so that "u"
-* can put it back there. */
+// can put it back there.
 curwin->w_cursor = oap->cursor_start;
 if (u_save((linenr_T)(oap->start.lnum - 1),
 				       (linenr_T)(oap->end.lnum + 1)) == FAIL)
 	return;
 curwin->w_cursor = oap->start;
 if (oap->is_VIsual)
-	/* When there is no change: need to remove the Visual selection */
+	// When there is no change: need to remove the Visual selection
 	redraw_curbuf_later(INVERTED);
 if (!cmdmod.lockmarks)
-	/* Set '[ mark at the start of the formatted area */
+	// Set '[ mark at the start of the formatted area
 	curbuf->b_op_start = oap->start;
-/* For "gw" remember the cursor position and put it back below (adjusted
+// For "gw" remember the cursor position and put it back below (adjusted
-* for joined and split lines). */
+// for joined and split lines).
 if (keep_cursor)
 	saved_cursor = oap->cursor_start;
 format_lines(oap->line_count, keep_cursor);
 beginline(BL_WHITE | BL_FIX);
 old_line_count = curbuf->b_ml.ml_line_count - old_line_count;
 msgmore(old_line_count);
 if (!cmdmod.lockmarks)
-	/* put '] mark on the end of the formatted area */
+	// put '] mark on the end of the formatted area
 	curbuf->b_op_end = curwin->w_cursor;
 if (keep_cursor)
 {
 	curwin->w_cursor = saved_cursor;
 	FOR_ALL_WINDOWS(wp)
 	{
 	    if (wp->w_old_cursor_lnum != 0)
 	    {
-		/* When lines have been inserted or deleted, adjust the end of
+		// When lines have been inserted or deleted, adjust the end of
-		 * the Visual area to be redrawn. */
+		// the Visual area to be redrawn.
 		if (wp->w_old_cursor_lnum > wp->w_old_visual_lnum)
 		    wp->w_old_cursor_lnum += old_line_count;
 		else
 		    wp->w_old_visual_lnum += old_line_count;
 	    }
 */
 static void
 op_formatexpr(oparg_T *oap)
 {
 if (oap->is_VIsual)
-	/* When there is no change: need to remove the Visual selection */
+	// When there is no change: need to remove the Visual selection
 	redraw_curbuf_later(INVERTED);
 if (fex_format(oap->start.lnum, oap->line_count, NUL) != 0)
-	/* As documented: when 'formatexpr' returns non-zero fall back to
+	// As documented: when 'formatexpr' returns non-zero fall back to
-	 * internal formatting. */
+	// internal formatting.
 	op_format(oap, FALSE);
 }
 int
 fex_format(
 linenr_T	lnum,
 long	count,
-int		c)	/* character to be inserted */
+int		c)	// character to be inserted
 {
 int		use_sandbox = was_set_insecurely((char_u *)"formatexpr",
 								   OPT_LOCAL);
 int		r;
 char_u	*fex;
 */
 set_vim_var_nr(VV_LNUM, lnum);
 set_vim_var_nr(VV_COUNT, count);
 set_vim_var_char(c);
-/* Make a copy, the option could be changed while calling it. */
+// Make a copy, the option could be changed while calling it.
 fex = vim_strsave(curbuf->b_p_fex);
 if (fex == NULL)
 	return 0;
 /*
 * first line.
 */
 void
 format_lines(
 linenr_T	line_count,
-int		avoid_fex)		/* don't use 'formatexpr' */
+int		avoid_fex)		// don't use 'formatexpr'
 {
 int		max_len;
-int		is_not_par;		/* current line not part of parag. */
+int		is_not_par;		// current line not part of parag.
-int		next_is_not_par;	/* next line not part of paragraph */
+int		next_is_not_par;	// next line not part of paragraph
-int		is_end_par;		/* at end of paragraph */
+int		is_end_par;		// at end of paragraph
-int		prev_is_end_par = FALSE;/* prev. line not part of parag. */
+int		prev_is_end_par = FALSE;// prev. line not part of parag.
 int		next_is_start_par = FALSE;
-int		leader_len = 0;		/* leader len of current line */
+int		leader_len = 0;		// leader len of current line
-int		next_leader_len;	/* leader len of next line */
+int		next_leader_len;	// leader len of next line
-char_u	*leader_flags = NULL;	/* flags for leader of current line */
+char_u	*leader_flags = NULL;	// flags for leader of current line
-char_u	*next_leader_flags;	/* flags for leader of next line */
+char_u	*next_leader_flags;	// flags for leader of next line
-int		do_comments;		/* format comments */
+int		do_comments;		// format comments
-int		do_comments_list = 0;	/* format comments with 'n' or '2' */
+int		do_comments_list = 0;	// format comments with 'n' or '2'
 int		advance = TRUE;
-int		second_indent = -1;	/* indent for second line (comment
+int		second_indent = -1;	// indent for second line (comment
-					 * aware) */
+					// aware)
 int		do_second_indent;
 int		do_number_indent;
 int		do_trail_white;
 int		first_par_line = TRUE;
 int		smd_save;
 long	count;
-int		need_set_indent = TRUE;	/* set indent of next paragraph */
+int		need_set_indent = TRUE;	// set indent of next paragraph
 int		force_format = FALSE;
 int		old_State = State;
-/* length of a line to force formatting: 3 * 'tw' */
+// length of a line to force formatting: 3 * 'tw'
 max_len = comp_textwidth(TRUE) * 3;
-/* check for 'q', '2' and '1' in 'formatoptions' */
+// check for 'q', '2' and '1' in 'formatoptions'
 do_comments = has_format_option(FO_Q_COMS);
 do_second_indent = has_format_option(FO_Q_SECOND);
 do_number_indent = has_format_option(FO_Q_NUMBER);
 do_trail_white = has_format_option(FO_WHITE_PAR);
 	    {
 		if (do_second_indent && !LINEEMPTY(curwin->w_cursor.lnum + 1))
 		{
 		    if (leader_len == 0 && next_leader_len == 0)
 		    {
-			/* no comment found */
+			// no comment found
 			second_indent =
 				   get_indent_lnum(curwin->w_cursor.lnum + 1);
 		    }
 		    else
 		    {
 		}
 		else if (do_number_indent)
 		{
 		    if (leader_len == 0 && next_leader_len == 0)
 		    {
-			/* no comment found */
+			// no comment found
 			second_indent =
 				     get_number_indent(curwin->w_cursor.lnum);
 		    }
 		    else
 		    {
-			/* get_number_indent() is now "comment aware"... */
+			// get_number_indent() is now "comment aware"...
 			second_indent =
 				     get_number_indent(curwin->w_cursor.lnum);
 			do_comments_list = 1;
 		    }
 		}
 	     * getting long, format it.
 	     */
 	    if (is_end_par || force_format)
 	    {
 		if (need_set_indent)
-		    /* replace indent in first line with minimal number of
+		    // replace indent in first line with minimal number of
-		     * tabs and spaces, according to current options */
+		    // tabs and spaces, according to current options
 		    (void)set_indent(get_indent(), SIN_CHANGED);
-		/* put cursor on last non-space */
+		// put cursor on last non-space
-		State = NORMAL;	/* don't go past end-of-line */
+		State = NORMAL;	// don't go past end-of-line
 		coladvance((colnr_T)MAXCOL);
 		while (curwin->w_cursor.col && vim_isspace(gchar_cursor()))
 		    dec_cursor();
-		/* do the formatting, without 'showmode' */
+		// do the formatting, without 'showmode'
-		State = INSERT;	/* for open_line() */
+		State = INSERT;	// for open_line()
 		smd_save = p_smd;
 		p_smd = FALSE;
 		insertchar(NUL, INSCHAR_FORMAT
 			+ (do_comments ? INSCHAR_DO_COM : 0)
 			+ (do_comments && do_comments_list
 						       ? INSCHAR_COM_LIST : 0)
 			+ (avoid_fex ? INSCHAR_NO_FEX : 0), second_indent);
 		State = old_State;
 		p_smd = smd_save;
 		second_indent = -1;
-		/* at end of par.: need to set indent of next par. */
+		// at end of par.: need to set indent of next par.
 		need_set_indent = is_end_par;
 		if (is_end_par)
 		{
-		    /* When called with a negative line count, break at the
+		    // When called with a negative line count, break at the
-		     * end of the paragraph. */
+		    // end of the paragraph.
 		    if (line_count < 0)
 			break;
 		    first_par_line = TRUE;
 		}
 		force_format = FALSE;
 		{
 		    beep_flush();
 		    break;
 		}
 		first_par_line = FALSE;
-		/* If the line is getting long, format it next time */
+		// If the line is getting long, format it next time
 		if (STRLEN(ml_get_curline()) > (size_t)max_len)
 		    force_format = TRUE;
 		else
 		    force_format = FALSE;
 	    }
 char_u	*s = ml_get(lnum);
 size_t	l;
 if (*s == NUL)
 	return FALSE;
-/* Don't use STRLEN() inside VIM_ISWHITE(), SAS/C complains: "macro
+// Don't use STRLEN() inside VIM_ISWHITE(), SAS/C complains: "macro
-* invocation may call function multiple times". */
+// invocation may call function multiple times".
 l = STRLEN(s) - 1;
 return VIM_ISWHITE(s[l]);
 }
 /*
 linenr_T	lnum,
 int		*leader_len,
 char_u	**leader_flags,
 int		do_comments)
 {
-char_u	*flags = NULL;	    /* init for GCC */
+char_u	*flags = NULL;	    // init for GCC
 char_u	*ptr;
 ptr = ml_get(lnum);
 if (do_comments)
 	*leader_len = get_leader_len(ptr, leader_flags, FALSE, TRUE);
 */
 int
 paragraph_start(linenr_T lnum)
 {
 char_u	*p;
-int		leader_len = 0;		/* leader len of current line */
+int		leader_len = 0;		// leader len of current line
-char_u	*leader_flags = NULL;	/* flags for leader of current line */
+char_u	*leader_flags = NULL;	// flags for leader of current line
-int		next_leader_len;	/* leader len of next line */
+int		next_leader_len;	// leader len of next line
-char_u	*next_leader_flags;	/* flags for leader of next line */
+char_u	*next_leader_flags;	// flags for leader of next line
-int		do_comments;		/* format comments */
+int		do_comments;		// format comments
 if (lnum <= 1)
-	return TRUE;		/* start of the file */
+	return TRUE;		// start of the file
 p = ml_get(lnum - 1);
 if (*p == NUL)
-	return TRUE;		/* after empty line */
+	return TRUE;		// after empty line
 do_comments = has_format_option(FO_Q_COMS);
 if (fmt_check_par(lnum - 1, &leader_len, &leader_flags, do_comments))
-	return TRUE;		/* after non-paragraph line */
+	return TRUE;		// after non-paragraph line
 if (fmt_check_par(lnum, &next_leader_len, &next_leader_flags, do_comments))
-	return TRUE;		/* "lnum" is not a paragraph line */
+	return TRUE;		// "lnum" is not a paragraph line
 if (has_format_option(FO_WHITE_PAR) && !ends_in_white(lnum - 1))
-	return TRUE;		/* missing trailing space in previous line. */
+	return TRUE;		// missing trailing space in previous line.
 if (has_format_option(FO_Q_NUMBER) && (get_number_indent(lnum) > 0))
-	return TRUE;		/* numbered item starts in "lnum". */
+	return TRUE;		// numbered item starts in "lnum".
 if (!same_leader(lnum - 1, leader_len, leader_flags,
 					  next_leader_len, next_leader_flags))
-	return TRUE;		/* change of comment leader. */
+	return TRUE;		// change of comment leader.
 return FALSE;
 }
 /*
 line = ml_get(lnum);
 pstart = line;
 prev_pstart = line;
 while (bdp->start_vcol < oap->start_vcol && *pstart)
 {
-	/* Count a tab for what it's worth (if list mode not on) */
+	// Count a tab for what it's worth (if list mode not on)
 	incr = lbr_chartabsize(line, pstart, (colnr_T)bdp->start_vcol);
 	bdp->start_vcol += incr;
 	if (VIM_ISWHITE(*pstart))
 	{
 	    bdp->pre_whitesp += incr;
 	}
 	prev_pstart = pstart;
 	MB_PTR_ADV(pstart);
 }
 bdp->start_char_vcols = incr;
-if (bdp->start_vcol < oap->start_vcol)	/* line too short */
+if (bdp->start_vcol < oap->start_vcol)	// line too short
 {
 	bdp->end_vcol = bdp->start_vcol;
 	bdp->is_short = TRUE;
 	if (!is_del || oap->op_type == OP_APPEND)
 	    bdp->endspaces = oap->end_vcol - oap->start_vcol + 1;
 }
 else
 {
-	/* notice: this converts partly selected Multibyte characters to
+	// notice: this converts partly selected Multibyte characters to
-	 * spaces, too. */
+	// spaces, too.
 	bdp->startspaces = bdp->start_vcol - oap->start_vcol;
 	if (is_del && bdp->startspaces)
 	    bdp->startspaces = bdp->start_char_vcols - bdp->startspaces;
 	pend = pstart;
 	bdp->end_vcol = bdp->start_vcol;
-	if (bdp->end_vcol > oap->end_vcol)	/* it's all in one character */
+	if (bdp->end_vcol > oap->end_vcol)	// it's all in one character
 	{
 	    bdp->is_oneChar = TRUE;
 	    if (oap->op_type == OP_INSERT)
 		bdp->endspaces = bdp->start_char_vcols - bdp->startspaces;
 	    else if (oap->op_type == OP_APPEND)
 	    else
 	    {
 		bdp->startspaces = oap->end_vcol - oap->start_vcol + 1;
 		if (is_del && oap->op_type != OP_LSHIFT)
 		{
-		    /* just putting the sum of those two into
+		    // just putting the sum of those two into
-		     * bdp->startspaces doesn't work for Visual replace,
+		    // bdp->startspaces doesn't work for Visual replace,
-		     * so we have to split the tab in two */
+		    // so we have to split the tab in two
 		    bdp->startspaces = bdp->start_char_vcols
 					- (bdp->start_vcol - oap->start_vcol);
 		    bdp->endspaces = bdp->end_vcol - oap->end_vcol - 1;
 		}
 	    }
 	else
 	{
 	    prev_pend = pend;
 	    while (bdp->end_vcol <= oap->end_vcol && *pend != NUL)
 	    {
-		/* Count a tab for what it's worth (if list mode not on) */
+		// Count a tab for what it's worth (if list mode not on)
 		prev_pend = pend;
 		incr = lbr_chartabsize_adv(line, &pend, (colnr_T)bdp->end_vcol);
 		bdp->end_vcol += incr;
 	    }
 	    if (bdp->end_vcol <= oap->end_vcol
 		    && (!is_del
 			|| oap->op_type == OP_APPEND
-			|| oap->op_type == OP_REPLACE)) /* line too short */
+			|| oap->op_type == OP_REPLACE)) // line too short
 	    {
 		bdp->is_short = TRUE;
-		/* Alternative: include spaces to fill up the block.
+		// Alternative: include spaces to fill up the block.
-		 * Disadvantage: can lead to trailing spaces when the line is
+		// Disadvantage: can lead to trailing spaces when the line is
-		 * short where the text is put */
+		// short where the text is put
-		/* if (!is_del || oap->op_type == OP_APPEND) */
+		// if (!is_del || oap->op_type == OP_APPEND)
 		if (oap->op_type == OP_APPEND || virtual_op)
 		    bdp->endspaces = oap->end_vcol - bdp->end_vcol
 							     + oap->inclusive;
 		else
-		    bdp->endspaces = 0; /* replace doesn't add characters */
+		    bdp->endspaces = 0; // replace doesn't add characters
 	    }
 	    else if (bdp->end_vcol > oap->end_vcol)
 	    {
 		bdp->endspaces = bdp->end_vcol - oap->end_vcol - 1;
 		if (!is_del && bdp->endspaces)
 * Handle the add/subtract operator.
 */
 void
 op_addsub(
 oparg_T	*oap,
-linenr_T	Prenum1,	    /* Amount of add/subtract */
+linenr_T	Prenum1,	    // Amount of add/subtract
-int		g_cmd)		    /* was g<c-a>/g<c-x> */
+int		g_cmd)		    // was g<c-a>/g<c-x>
 {
 pos_T		pos;
 struct block_def	bd;
 int			change_cnt = 0;
 linenr_T		amount = Prenum1;
 	}
 	pos = oap->start;
 	for (; pos.lnum <= oap->end.lnum; ++pos.lnum)
 	{
-	    if (oap->block_mode)		    /* Visual block mode */
+	    if (oap->block_mode)		    // Visual block mode
 	    {
 		block_prep(oap, &bd, pos.lnum, FALSE);
 		pos.col = bd.textcol;
 		length = bd.textlen;
 	    }
 	    {
 		curwin->w_cursor.col = 0;
 		pos.col = 0;
 		length = (colnr_T)STRLEN(ml_get(pos.lnum));
 	    }
-	    else /* oap->motion_type == MCHAR */
+	    else // oap->motion_type == MCHAR
 	    {
 		if (pos.lnum == oap->start.lnum && !oap->inclusive)
 		    dec(&(oap->end));
 		length = (colnr_T)STRLEN(ml_get(pos.lnum));
 		pos.col = 0;
 		}
 	    }
 	    one_change = do_addsub(oap->op_type, &pos, length, amount);
 	    if (one_change)
 	    {
-		/* Remember the start position of the first change. */
+		// Remember the start position of the first change.
 		if (change_cnt == 0)
 		    startpos = curbuf->b_op_start;
 		++change_cnt;
 	    }
 #endif
 	if (change_cnt)
 	    changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L);
 	if (!change_cnt && oap->is_VIsual)
-	    /* No change: need to remove the Visual selection */
+	    // No change: need to remove the Visual selection
 	    redraw_curbuf_later(INVERTED);
-	/* Set '[ mark if something changed. Keep the last end
+	// Set '[ mark if something changed. Keep the last end
-	 * position from do_addsub(). */
+	// position from do_addsub().
 	if (change_cnt > 0 && !cmdmod.lockmarks)
 	    curbuf->b_op_start = startpos;
 	if (change_cnt > p_report)
 	    smsg(NGETTEXT("%ld line changed", "%ld lines changed",
 linenr_T	Prenum1)
 {
 int		col;
 char_u	*buf1;
 char_u	buf2[NUMBUFLEN];
-int		pre;		/* 'X'/'x': hex; '0': octal; 'B'/'b': bin */
+int		pre;		// 'X'/'x': hex; '0': octal; 'B'/'b': bin
-static int	hexupper = FALSE;	/* 0xABC */
+static int	hexupper = FALSE;	// 0xABC
 uvarnumber_T	n;
 uvarnumber_T	oldn;
 char_u	*ptr;
 int		c;
 int		todel;
 		    && (!has_mbyte ||
 			!(*mb_head_off)(ptr, ptr + col - 1))
 		    && vim_isxdigit(ptr[col + 1]))))
 	{
-	    /* In case of binary/hexadecimal pattern overlap match, rescan */
+	    // In case of binary/hexadecimal pattern overlap match, rescan
 	    col = pos->col;
 	    while (col > 0 && vim_isdigit(ptr[col]))
 	    {
 		&& ptr[col - 1] == '0'
 		&& (!has_mbyte ||
 		    !(*mb_head_off)(ptr, ptr + col - 1))
 		&& vim_isbdigit(ptr[col + 1])))
 	{
-	    /* Found hexadecimal or binary number, move to its start. */
+	    // Found hexadecimal or binary number, move to its start.
 	    --col;
 	    if (has_mbyte)
 		col -= (*mb_head_off)(ptr, ptr + col);
 	}
 	else
 	goto theend;
 }
 if (doalp && ASCII_ISALPHA(firstdigit))
 {
-	/* decrement or increment alphabetic character */
+	// decrement or increment alphabetic character
 	if (op_type == OP_NR_SUB)
 	{
 	    if (CharOrd(firstdigit) < Prenum1)
 	    {
 		if (isupper(firstdigit))
 	if (col > 0 && ptr[col - 1] == '-'
 		&& (!has_mbyte ||
 		    !(*mb_head_off)(ptr, ptr + col - 1))
 		&& !visual)
 	{
-	    /* negative number */
+	    // negative number
 	    --col;
 	    negative = TRUE;
 	}
-	/* get the number value (unsigned) */
+	// get the number value (unsigned)
 	if (visual && VIsual_mode != 'V')
 	    maxlen = (curbuf->b_visual.vi_curswant == MAXCOL
 		    ? (int)STRLEN(ptr) - col
 		    : length);
 		0 + (dobin ? STR2NR_BIN : 0)
 		    + (dooct ? STR2NR_OCT : 0)
 		    + (dohex ? STR2NR_HEX : 0),
 		NULL, &n, maxlen, FALSE);
-	/* ignore leading '-' for hex and octal and bin numbers */
+	// ignore leading '-' for hex and octal and bin numbers
 	if (pre && negative)
 	{
 	    ++col;
 	    --length;
 	    negative = FALSE;
 	}
-	/* add or subtract */
+	// add or subtract
 	subtract = FALSE;
 	if (op_type == OP_NR_SUB)
 	    subtract ^= TRUE;
 	if (negative)
 	    subtract ^= TRUE;
 	oldn = n;
 	if (subtract)
 	    n -= (uvarnumber_T)Prenum1;
 	else
 	    n += (uvarnumber_T)Prenum1;
-	/* handle wraparound for decimal numbers */
+	// handle wraparound for decimal numbers
 	if (!pre)
 	{
 	    if (subtract)
 	    {
 		if (n > oldn)
 		    negative ^= TRUE;
 		}
 	    }
 	    else
 	    {
-		/* add */
+		// add
 		if (n < oldn)
 		{
 		    n = (n ^ (uvarnumber_T)-1);
 		    negative ^= TRUE;
 		}
 		negative = FALSE;
 	}
 	if (visual && !was_positive && !negative && col > 0)
 	{
-	    /* need to remove the '-' */
+	    // need to remove the '-'
 	    col--;
 	    length++;
 	}
 	/*
 		if (isupper(c))
 		    hexupper = TRUE;
 		else
 		    hexupper = FALSE;
 	    }
-	    /* del_char() will mark line needing displaying */
+	    // del_char() will mark line needing displaying
 	    (void)del_char(FALSE);
 	    c = gchar_cursor();
 	}
 	/*
 	{
 	    int i;
 	    int bit = 0;
 	    int bits = sizeof(uvarnumber_T) * 8;
-	    /* leading zeros */
+	    // leading zeros
 	    for (bit = bits; bit > 0; bit--)
 		if ((n >> (bit - 1)) & 0x1) break;
 	    for (i = 0; bit > 0; bit--)
 		buf2[i++] = ((n >> (bit - 1)) & 0x1) ? '1' : '0';
 	if (firstdigit == '0' && !(dooct && pre == 0))
 	    while (length-- > 0)
 		*ptr++ = '0';
 	*ptr = NUL;
 	STRCAT(buf1, buf2);
-	ins_str(buf1);		/* insert the new number */
+	ins_str(buf1);		// insert the new number
 	vim_free(buf1);
 	endpos = curwin->w_cursor;
 	if (did_change && curwin->w_cursor.col)
 	    --curwin->w_cursor.col;
 }
 if (did_change && !cmdmod.lockmarks)
 {
-	/* set the '[ and '] marks */
+	// set the '[ and '] marks
 	curbuf->b_op_start = startpos;
 	curbuf->b_op_end = endpos;
 	if (curbuf->b_op_end.col > 0)
 	    --curbuf->b_op_end.col;
 }
 	dpy = xterm_dpy;
 # else
 	return;
 # endif
-/* Get selection to export */
+// Get selection to export
 if (clip_plus.owned)
 	motion_type = clip_convert_selection(&str, &len, &clip_plus);
 else if (clip_star.owned)
 	motion_type = clip_convert_selection(&str, &len, &clip_star);
-/* Check it's OK */
+// Check it's OK
 if (dpy != NULL && str != NULL && motion_type >= 0
 					       && len < 1024*1024 && len > 0)
 {
 	int ok = TRUE;
-	/* The CUT_BUFFER0 is supposed to always contain latin1.  Convert from
+	// The CUT_BUFFER0 is supposed to always contain latin1.  Convert from
-	 * 'enc' when it is a multi-byte encoding.  When 'enc' is an 8-bit
+	// 'enc' when it is a multi-byte encoding.  When 'enc' is an 8-bit
-	 * encoding conversion usually doesn't work, so keep the text as-is.
+	// encoding conversion usually doesn't work, so keep the text as-is.
-	 */
 	if (has_mbyte)
 	{
 	    vimconv_T	vc;
 	    vc.vc_type = CONV_NONE;
 	    {
 		ok = FALSE;
 	    }
 	}
-	/* Do not store the string if conversion failed.  Better to use any
+	// Do not store the string if conversion failed.  Better to use any
-	 * other selection than garbled text. */
+	// other selection than garbled text.
 	if (ok)
 	{
 	    XStoreBuffer(dpy, (char *)str, (int)len, 0);
 	    XFlush(dpy);
 	}
 }
 vim_free(str);
 }
 #endif
-#endif /* FEAT_CLIPBOARD || PROTO */
+#endif // FEAT_CLIPBOARD || PROTO
 void
 clear_oparg(oparg_T *oap)
 {
 vim_memset(oap, 0, sizeof(oparg_T));
 if (is_word)
 	words++;
 *wc += words;
-/* Add eol_size if the end of line was reached before hitting limit. */
+// Add eol_size if the end of line was reached before hitting limit.
 if (i < limit && line[i] == NUL)
 {
 	i += eol_size;
 	chars += eol_size;
 }
 	    {
 #ifdef FEAT_LINEBREAK
 		char_u * saved_sbr = p_sbr;
 		char_u * saved_w_sbr = curwin->w_p_sbr;
-		/* Make 'sbr' empty for a moment to get the correct size. */
+		// Make 'sbr' empty for a moment to get the correct size.
 		p_sbr = empty_option;
 		curwin->w_p_sbr = empty_option;
 #endif
 		oparg.is_VIsual = 1;
 		oparg.block_mode = TRUE;
 		p_sbr = saved_sbr;
 		curwin->w_p_sbr = saved_w_sbr;
 #endif
 		if (curwin->w_curswant == MAXCOL)
 		    oparg.end_vcol = MAXCOL;
-		/* Swap the start, end vcol if needed */
+		// Swap the start, end vcol if needed
 		if (oparg.end_vcol < oparg.start_vcol)
 		{
 		    oparg.end_vcol += oparg.start_vcol;
 		    oparg.start_vcol = oparg.end_vcol - oparg.start_vcol;
 		    oparg.end_vcol -= oparg.start_vcol;
 	    line_count_selected = max_pos.lnum - min_pos.lnum + 1;
 	}
 	for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; ++lnum)
 	{
-	    /* Check for a CTRL-C every 100000 characters. */
+	    // Check for a CTRL-C every 100000 characters.
 	    if (byte_count > last_check)
 	    {
 		ui_breakcheck();
 		if (got_int)
 		    return;
 		last_check = byte_count + 100000L;
 	    }
-	    /* Do extra processing for VIsual mode. */
+	    // Do extra processing for VIsual mode.
 	    if (VIsual_active
 		    && lnum >= min_pos.lnum && lnum <= max_pos.lnum)
 	    {
 		char_u	    *s = NULL;
 		long	    len = 0L;
 			byte_count_cursor -= eol_size;
 		}
 	    }
 	    else
 	    {
-		/* In non-visual mode, check for the line the cursor is on */
+		// In non-visual mode, check for the line the cursor is on
 		if (lnum == curwin->w_cursor.lnum)
 		{
 		    word_count_cursor += word_count;
 		    char_count_cursor += char_count;
 		    byte_count_cursor = byte_count +
 				&word_count_cursor, &char_count_cursor,
 				(varnumber_T)(curwin->w_cursor.col + 1),
 				eol_size);
 		}
 	    }
-	    /* Add to the running totals */
+	    // Add to the running totals
 	    byte_count += line_count_info(ml_get(lnum), &word_count,
 					 &char_count, (varnumber_T)MAXCOL,
 					 eol_size);
 	}
-	/* Correction for when last line doesn't have an EOL. */
+	// Correction for when last line doesn't have an EOL.
 	if (!curbuf->b_p_eol && (curbuf->b_p_bin || !curbuf->b_p_fixeol))
 	    byte_count -= eol_size;
 	if (dict == NULL)
 	{
 		// Prepare for redoing.  Only use the nchar field for "r",
 		// otherwise it might be the second char of the operator.
 		if (cap->cmdchar == 'g' && (cap->nchar == 'n'
 							|| cap->nchar == 'N'))
 		    prep_redo(oap->regname, cap->count0,
-			    get_op_char(oap->op_type), get_extra_op_char(oap->op_type),
+			    get_op_char(oap->op_type),
+			    get_extra_op_char(oap->op_type),
 			    oap->motion_force, cap->cmdchar, cap->nchar);
 		else if (cap->cmdchar != ':')
 		{
 		    int nchar = oap->op_type == OP_REPLACE ? cap->nchar : NUL;

Mercurial > vim

comparison src/ops.c @ 18808:7982f65d8f54 v8.1.2392