move open_line

2 files changed, 824 insertions, 1801 deletions

diff --git a/src/nvim/change.c b/src/nvim/change.c
index 2b247d09e2..26bca82103 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -920,963 +920,859 @@ int copy_indent(int size, char_u *src)
  * "second_line_indent": indent for after ^^D in Insert mode or if flag
  *			  OPENLINE_COM_LIST
  *
- * Return OK for success, FAIL for failure
+ * Return TRUE for success, FALSE for failure
  */
-    int
-open_line(
-    int		dir,		// FORWARD or BACKWARD
-    int		flags,
-    int		second_line_indent)
+int 
+open_line (
+    int dir,                        /* FORWARD or BACKWARD */
+    int flags,
+    int second_line_indent
+)
 {
-    char_u	*saved_line;		// copy of the original line
-    char_u	*next_line = NULL;	// copy of the next line
-    char_u	*p_extra = NULL;	// what goes to next line
-    int		less_cols = 0;		// less columns for mark in new line
-    int		less_cols_off = 0;	// columns to skip for mark adjust
-    pos_T	old_cursor;		// old cursor position
-    int		newcol = 0;		// new cursor column
-    int		newindent = 0;		// auto-indent of the new line
-    int		n;
-    int		trunc_line = FALSE;	// truncate current line afterwards
-    int		retval = FAIL;		// return value
-#ifdef FEAT_COMMENTS
-    int		extra_len = 0;		// length of p_extra string
-    int		lead_len;		// length of comment leader
-    char_u	*lead_flags;	// position in 'comments' for comment leader
-    char_u	*leader = NULL;		// copy of comment leader
-#endif
-    char_u	*allocated = NULL;	// allocated memory
-    char_u	*p;
-    int		saved_char = NUL;	// init for GCC
-#if defined(FEAT_SMARTINDENT) || defined(FEAT_COMMENTS)
-    pos_T	*pos;
-#endif
-#ifdef FEAT_SMARTINDENT
-    int		do_si = (!p_paste && curbuf->b_p_si
-# ifdef FEAT_CINDENT
-					&& !curbuf->b_p_cin
-# endif
-# ifdef FEAT_EVAL
-					&& *curbuf->b_p_inde == NUL
-# endif
-			);
-    int		no_si = FALSE;		// reset did_si afterwards
-    int		first_char = NUL;	// init for GCC
-#endif
-#if defined(FEAT_LISP) || defined(FEAT_CINDENT)
-    int		vreplace_mode;
-#endif
-    int		did_append;		// appended a new line
-    int		saved_pi = curbuf->b_p_pi; // copy of preserveindent setting
-
-    // make a copy of the current line so we can mess with it
-    saved_line = vim_strsave(ml_get_curline());
-    if (saved_line == NULL)	    /* out of memory! */
-	return FALSE;
-
-    if (State & VREPLACE_FLAG)
-    {
-	// With VREPLACE we make a copy of the next line, which we will be
-	// starting to replace.  First make the new line empty and let vim play
-	// with the indenting and comment leader to its heart's content.  Then
-	// we grab what it ended up putting on the new line, put back the
-	// original line, and call ins_char() to put each new character onto
-	// the line, replacing what was there before and pushing the right
-	// stuff onto the replace stack.  -- webb.
-	if (curwin->w_cursor.lnum < orig_line_count)
-	    next_line = vim_strsave(ml_get(curwin->w_cursor.lnum + 1));
-	else
-	    next_line = vim_strsave((char_u *)"");
-	if (next_line == NULL)	    // out of memory!
-	    goto theend;
-
-	// In VREPLACE mode, a NL replaces the rest of the line, and starts
-	// replacing the next line, so push all of the characters left on the
-	// line onto the replace stack.  We'll push any other characters that
-	// might be replaced at the start of the next line (due to autoindent
-	// etc) a bit later.
-	replace_push(NUL);  // Call twice because BS over NL expects it
-	replace_push(NUL);
-	p = saved_line + curwin->w_cursor.col;
-	while (*p != NUL)
-	{
-	    if (has_mbyte)
-		p += replace_push_mb(p);
-	    else
-		replace_push(*p++);
-	}
-	saved_line[curwin->w_cursor.col] = NUL;
-    }
+  char_u *next_line = NULL;       // copy of the next line
+  char_u *p_extra = NULL;         // what goes to next line
+  colnr_T less_cols = 0;          // less columns for mark in new line
+  colnr_T less_cols_off = 0;      // columns to skip for mark adjust
+  pos_T old_cursor;               // old cursor position
+  colnr_T newcol = 0;             // new cursor column
+  int newindent = 0;              // auto-indent of the new line
+  bool trunc_line = false;        // truncate current line afterwards
+  bool retval = false;            // return value
+  int extra_len = 0;              // length of p_extra string
+  int lead_len;                   // length of comment leader
+  char_u *lead_flags;             // position in 'comments' for comment leader
+  char_u *leader = NULL;          // copy of comment leader
+  char_u *allocated = NULL;       // allocated memory
+  char_u *p;
+  char_u saved_char = NUL;        // init for GCC
+  pos_T *pos;
+  bool do_si = (!p_paste && curbuf->b_p_si && !curbuf->b_p_cin
+                && *curbuf->b_p_inde == NUL);
+  bool no_si = false;             // reset did_si afterwards
+  int first_char = NUL;           // init for GCC
+  int vreplace_mode;
+  bool did_append;                // appended a new line
+  int saved_pi = curbuf->b_p_pi;  // copy of preserveindent setting
+
+  // make a copy of the current line so we can mess with it
+  char_u *saved_line = vim_strsave(get_cursor_line_ptr());
+
+  if (State & VREPLACE_FLAG) {
+    /*
+     * With VREPLACE we make a copy of the next line, which we will be
+     * starting to replace.  First make the new line empty and let vim play
+     * with the indenting and comment leader to its heart's content.  Then
+     * we grab what it ended up putting on the new line, put back the
+     * original line, and call ins_char() to put each new character onto
+     * the line, replacing what was there before and pushing the right
+     * stuff onto the replace stack.  -- webb.
+     */
+    if (curwin->w_cursor.lnum < orig_line_count)
+      next_line = vim_strsave(ml_get(curwin->w_cursor.lnum + 1));
+    else
+      next_line = vim_strsave((char_u *)"");
 
-    if ((State & INSERT) && !(State & VREPLACE_FLAG))
-    {
-	p_extra = saved_line + curwin->w_cursor.col;
-#ifdef FEAT_SMARTINDENT
-	if (do_si)		// need first char after new line break
-	{
-	    p = skipwhite(p_extra);
-	    first_char = *p;
-	}
-#endif
-#ifdef FEAT_COMMENTS
-	extra_len = (int)STRLEN(p_extra);
-#endif
-	saved_char = *p_extra;
-	*p_extra = NUL;
+    /*
+     * In VREPLACE mode, a NL replaces the rest of the line, and starts
+     * replacing the next line, so push all of the characters left on the
+     * line onto the replace stack.  We'll push any other characters that
+     * might be replaced at the start of the next line (due to autoindent
+     * etc) a bit later.
+     */
+    replace_push(NUL);      /* Call twice because BS over NL expects it */
+    replace_push(NUL);
+    p = saved_line + curwin->w_cursor.col;
+    while (*p != NUL) {
+      if (has_mbyte)
+        p += replace_push_mb(p);
+      else
+        replace_push(*p++);
     }
+    saved_line[curwin->w_cursor.col] = NUL;
+  }
 
-    u_clearline();		// cannot do "U" command when adding lines
-#ifdef FEAT_SMARTINDENT
-    did_si = FALSE;
-#endif
-    ai_col = 0;
-
-    // If we just did an auto-indent, then we didn't type anything on
-    // the prior line, and it should be truncated.  Do this even if 'ai' is not
-    // set because automatically inserting a comment leader also sets did_ai.
-    if (dir == FORWARD && did_ai)
-	trunc_line = TRUE;
-
-    // If 'autoindent' and/or 'smartindent' is set, try to figure out what
-    // indent to use for the new line.
-    if (curbuf->b_p_ai
-#ifdef FEAT_SMARTINDENT
-			|| do_si
-#endif
-					    )
-    {
-	// count white space on current line
-#ifdef FEAT_VARTABS
-	newindent = get_indent_str_vtab(saved_line, curbuf->b_p_ts,
-						 curbuf->b_p_vts_array, FALSE);
-#else
-	newindent = get_indent_str(saved_line, (int)curbuf->b_p_ts, FALSE);
-#endif
-	if (newindent == 0 && !(flags & OPENLINE_COM_LIST))
-	    newindent = second_line_indent; // for ^^D command in insert mode
-
-#ifdef FEAT_SMARTINDENT
-	// Do smart indenting.
-	// In insert/replace mode (only when dir == FORWARD)
-	// we may move some text to the next line. If it starts with '{'
-	// don't add an indent. Fixes inserting a NL before '{' in line
-	//	"if (condition) {"
-	if (!trunc_line && do_si && *saved_line != NUL
-				    && (p_extra == NULL || first_char != '{'))
-	{
-	    char_u  *ptr;
-	    char_u  last_char;
-
-	    old_cursor = curwin->w_cursor;
-	    ptr = saved_line;
-# ifdef FEAT_COMMENTS
-	    if (flags & OPENLINE_DO_COM)
-		lead_len = get_leader_len(ptr, NULL, FALSE, TRUE);
-	    else
-		lead_len = 0;
-# endif
-	    if (dir == FORWARD)
-	    {
-		// Skip preprocessor directives, unless they are
-		// recognised as comments.
-		if (
-# ifdef FEAT_COMMENTS
-			lead_len == 0 &&
-# endif
-			ptr[0] == '#')
-		{
-		    while (ptr[0] == '#' && curwin->w_cursor.lnum > 1)
-			ptr = ml_get(--curwin->w_cursor.lnum);
-		    newindent = get_indent();
-		}
-# ifdef FEAT_COMMENTS
-		if (flags & OPENLINE_DO_COM)
-		    lead_len = get_leader_len(ptr, NULL, FALSE, TRUE);
-		else
-		    lead_len = 0;
-		if (lead_len > 0)
-		{
-		    // This case gets the following right:
-		    //	    /*
-		    //	     * A comment (read '\' as '/').
-		    //	     */
-		    // #define IN_THE_WAY
-		    //	    This should line up here;
-		    p = skipwhite(ptr);
-		    if (p[0] == '/' && p[1] == '*')
-			p++;
-		    if (p[0] == '*')
-		    {
-			for (p++; *p; p++)
-			{
-			    if (p[0] == '/' && p[-1] == '*')
-			    {
-				// End of C comment, indent should line up
-				// with the line containing the start of
-				// the comment
-				curwin->w_cursor.col = (colnr_T)(p - ptr);
-				if ((pos = findmatch(NULL, NUL)) != NULL)
-				{
-				    curwin->w_cursor.lnum = pos->lnum;
-				    newindent = get_indent();
-				}
-			    }
-			}
-		    }
-		}
-		else	// Not a comment line
-# endif
-		{
-		    // Find last non-blank in line
-		    p = ptr + STRLEN(ptr) - 1;
-		    while (p > ptr && VIM_ISWHITE(*p))
-			--p;
-		    last_char = *p;
-
-		    // find the character just before the '{' or ';'
-		    if (last_char == '{' || last_char == ';')
-		    {
-			if (p > ptr)
-			    --p;
-			while (p > ptr && VIM_ISWHITE(*p))
-			    --p;
-		    }
-		    // Try to catch lines that are split over multiple
-		    // lines.  eg:
-		    //	    if (condition &&
-		    //			condition) {
-		    //		Should line up here!
-		    //	    }
-		    if (*p == ')')
-		    {
-			curwin->w_cursor.col = (colnr_T)(p - ptr);
-			if ((pos = findmatch(NULL, '(')) != NULL)
-			{
-			    curwin->w_cursor.lnum = pos->lnum;
-			    newindent = get_indent();
-			    ptr = ml_get_curline();
-			}
-		    }
-		    // If last character is '{' do indent, without
-		    // checking for "if" and the like.
-		    if (last_char == '{')
-		    {
-			did_si = TRUE;	// do indent
-			no_si = TRUE;	// don't delete it when '{' typed
-		    }
-		    // Look for "if" and the like, use 'cinwords'.
-		    // Don't do this if the previous line ended in ';' or
-		    // '}'.
-		    else if (last_char != ';' && last_char != '}'
-						       && cin_is_cinword(ptr))
-			did_si = TRUE;
-		}
-	    }
-	    else // dir == BACKWARD
-	    {
-		// Skip preprocessor directives, unless they are
-		// recognised as comments.
-		if (
-# ifdef FEAT_COMMENTS
-			lead_len == 0 &&
-# endif
-			ptr[0] == '#')
-		{
-		    int was_backslashed = FALSE;
-
-		    while ((ptr[0] == '#' || was_backslashed) &&
-			 curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
-		    {
-			if (*ptr && ptr[STRLEN(ptr) - 1] == '\\')
-			    was_backslashed = TRUE;
-			else
-			    was_backslashed = FALSE;
-			ptr = ml_get(++curwin->w_cursor.lnum);
-		    }
-		    if (was_backslashed)
-			newindent = 0;	    // Got to end of file
-		    else
-			newindent = get_indent();
-		}
-		p = skipwhite(ptr);
-		if (*p == '}')	    // if line starts with '}': do indent
-		    did_si = TRUE;
-		else		    // can delete indent when '{' typed
-		    can_si_back = TRUE;
-	    }
-	    curwin->w_cursor = old_cursor;
-	}
-	if (do_si)
-	    can_si = TRUE;
-#endif // FEAT_SMARTINDENT
-
-	did_ai = TRUE;
+  if ((State & INSERT)
+      && !(State & VREPLACE_FLAG)
+      ) {
+    p_extra = saved_line + curwin->w_cursor.col;
+    if (do_si) {                /* need first char after new line break */
+      p = skipwhite(p_extra);
+      first_char = *p;
     }
+    extra_len = (int)STRLEN(p_extra);
+    saved_char = *p_extra;
+    *p_extra = NUL;
+  }
 
-#ifdef FEAT_COMMENTS
-    // Find out if the current line starts with a comment leader.
-    // This may then be inserted in front of the new line.
-    end_comment_pending = NUL;
-    if (flags & OPENLINE_DO_COM)
-	lead_len = get_leader_len(saved_line, &lead_flags,
-							dir == BACKWARD, TRUE);
-    else
-	lead_len = 0;
-    if (lead_len > 0)
-    {
-	char_u	*lead_repl = NULL;	    // replaces comment leader
-	int	lead_repl_len = 0;	    // length of *lead_repl
-	char_u	lead_middle[COM_MAX_LEN];   // middle-comment string
-	char_u	lead_end[COM_MAX_LEN];	    // end-comment string
-	char_u	*comment_end = NULL;	    // where lead_end has been found
-	int	extra_space = FALSE;	    // append extra space
-	int	current_flag;
-	int	require_blank = FALSE;	    // requires blank after middle
-	char_u	*p2;
-
-	// If the comment leader has the start, middle or end flag, it may not
-	// be used or may be replaced with the middle leader.
-	for (p = lead_flags; *p && *p != ':'; ++p)
-	{
-	    if (*p == COM_BLANK)
-	    {
-		require_blank = TRUE;
-		continue;
-	    }
-	    if (*p == COM_START || *p == COM_MIDDLE)
-	    {
-		current_flag = *p;
-		if (*p == COM_START)
-		{
-		    // Doing "O" on a start of comment does not insert leader.
-		    if (dir == BACKWARD)
-		    {
-			lead_len = 0;
-			break;
-		    }
-
-		    // find start of middle part
-		    (void)copy_option_part(&p, lead_middle, COM_MAX_LEN, ",");
-		    require_blank = FALSE;
-		}
-
-		// Isolate the strings of the middle and end leader.
-		while (*p && p[-1] != ':')	/* find end of middle flags */
-		{
-		    if (*p == COM_BLANK)
-			require_blank = TRUE;
-		    ++p;
-		}
-		(void)copy_option_part(&p, lead_middle, COM_MAX_LEN, ",");
-
-		while (*p && p[-1] != ':')	// find end of end flags
-		{
-		    // Check whether we allow automatic ending of comments
-		    if (*p == COM_AUTO_END)
-			end_comment_pending = -1; // means we want to set it
-		    ++p;
-		}
-		n = copy_option_part(&p, lead_end, COM_MAX_LEN, ",");
-
-		if (end_comment_pending == -1)	// we can set it now
-		    end_comment_pending = lead_end[n - 1];
-
-		// If the end of the comment is in the same line, don't use
-		// the comment leader.
-		if (dir == FORWARD)
-		{
-		    for (p = saved_line + lead_len; *p; ++p)
-			if (STRNCMP(p, lead_end, n) == 0)
-			{
-			    comment_end = p;
-			    lead_len = 0;
-			    break;
-			}
-		}
-
-		// Doing "o" on a start of comment inserts the middle leader.
-		if (lead_len > 0)
-		{
-		    if (current_flag == COM_START)
-		    {
-			lead_repl = lead_middle;
-			lead_repl_len = (int)STRLEN(lead_middle);
-		    }
-
-		    // If we have hit RETURN immediately after the start
-		    // comment leader, then put a space after the middle
-		    // comment leader on the next line.
-		    if (!VIM_ISWHITE(saved_line[lead_len - 1])
-			    && ((p_extra != NULL
-				    && (int)curwin->w_cursor.col == lead_len)
-				|| (p_extra == NULL
-				    && saved_line[lead_len] == NUL)
-				|| require_blank))
-			extra_space = TRUE;
-		}
-		break;
-	    }
-	    if (*p == COM_END)
-	    {
-		// Doing "o" on the end of a comment does not insert leader.
-		// Remember where the end is, might want to use it to find the
-		// start (for C-comments).
-		if (dir == FORWARD)
-		{
-		    comment_end = skipwhite(saved_line);
-		    lead_len = 0;
-		    break;
-		}
-
-		// Doing "O" on the end of a comment inserts the middle leader.
-		// Find the string for the middle leader, searching backwards.
-		while (p > curbuf->b_p_com && *p != ',')
-		    --p;
-		for (lead_repl = p; lead_repl > curbuf->b_p_com
-					 && lead_repl[-1] != ':'; --lead_repl)
-		    ;
-		lead_repl_len = (int)(p - lead_repl);
-
-		// We can probably always add an extra space when doing "O" on
-		// the comment-end
-		extra_space = TRUE;
-
-		// Check whether we allow automatic ending of comments
-		for (p2 = p; *p2 && *p2 != ':'; p2++)
-		{
-		    if (*p2 == COM_AUTO_END)
-			end_comment_pending = -1; // means we want to set it
-		}
-		if (end_comment_pending == -1)
-		{
-		    // Find last character in end-comment string
-		    while (*p2 && *p2 != ',')
-			p2++;
-		    end_comment_pending = p2[-1];
-		}
-		break;
-	    }
-	    if (*p == COM_FIRST)
-	    {
-		// Comment leader for first line only:	Don't repeat leader
-		// when using "O", blank out leader when using "o".
-		if (dir == BACKWARD)
-		    lead_len = 0;
-		else
-		{
-		    lead_repl = (char_u *)"";
-		    lead_repl_len = 0;
-		}
-		break;
-	    }
-	}
-	if (lead_len)
-	{
-	    // allocate buffer (may concatenate p_extra later)
-	    leader = alloc(lead_len + lead_repl_len + extra_space + extra_len
-		     + (second_line_indent > 0 ? second_line_indent : 0) + 1);
-	    allocated = leader;		    // remember to free it later
-
-	    if (leader == NULL)
-		lead_len = 0;
-	    else
-	    {
-		vim_strncpy(leader, saved_line, lead_len);
-
-		// Replace leader with lead_repl, right or left adjusted
-		if (lead_repl != NULL)
-		{
-		    int		c = 0;
-		    int		off = 0;
-
-		    for (p = lead_flags; *p != NUL && *p != ':'; )
-		    {
-			if (*p == COM_RIGHT || *p == COM_LEFT)
-			    c = *p++;
-			else if (VIM_ISDIGIT(*p) || *p == '-')
-			    off = getdigits(&p);
-			else
-			    ++p;
-		    }
-		    if (c == COM_RIGHT)    // right adjusted leader
-		    {
-			// find last non-white in the leader to line up with
-			for (p = leader + lead_len - 1; p > leader
-						      && VIM_ISWHITE(*p); --p)
-			    ;
-			++p;
-
-			// Compute the length of the replaced characters in
-			// screen characters, not bytes.
-			{
-			    int	    repl_size = vim_strnsize(lead_repl,
-							       lead_repl_len);
-			    int	    old_size = 0;
-			    char_u  *endp = p;
-			    int	    l;
-
-			    while (old_size < repl_size && p > leader)
-			    {
-				MB_PTR_BACK(leader, p);
-				old_size += ptr2cells(p);
-			    }
-			    l = lead_repl_len - (int)(endp - p);
-			    if (l != 0)
-				mch_memmove(endp + l, endp,
-					(size_t)((leader + lead_len) - endp));
-			    lead_len += l;
-			}
-			mch_memmove(p, lead_repl, (size_t)lead_repl_len);
-			if (p + lead_repl_len > leader + lead_len)
-			    p[lead_repl_len] = NUL;
-
-			// blank-out any other chars from the old leader.
-			while (--p >= leader)
-			{
-			    int l = mb_head_off(leader, p);
-
-			    if (l > 1)
-			    {
-				p -= l;
-				if (ptr2cells(p) > 1)
-				{
-				    p[1] = ' ';
-				    --l;
-				}
-				mch_memmove(p + 1, p + l + 1,
-				   (size_t)((leader + lead_len) - (p + l + 1)));
-				lead_len -= l;
-				*p = ' ';
-			    }
-			    else if (!VIM_ISWHITE(*p))
-				*p = ' ';
-			}
-		    }
-		    else	// left adjusted leader
-		    {
-			p = skipwhite(leader);
-
-			// Compute the length of the replaced characters in
-			// screen characters, not bytes. Move the part that is
-			// not to be overwritten.
-			{
-			    int	    repl_size = vim_strnsize(lead_repl,
-							       lead_repl_len);
-			    int	    i;
-			    int	    l;
-
-			    for (i = 0; i < lead_len && p[i] != NUL; i += l)
-			    {
-				l = (*mb_ptr2len)(p + i);
-				if (vim_strnsize(p, i + l) > repl_size)
-				    break;
-			    }
-			    if (i != lead_repl_len)
-			    {
-				mch_memmove(p + lead_repl_len, p + i,
-				       (size_t)(lead_len - i - (p - leader)));
-				lead_len += lead_repl_len - i;
-			    }
-			}
-			mch_memmove(p, lead_repl, (size_t)lead_repl_len);
-
-			// Replace any remaining non-white chars in the old
-			// leader by spaces.  Keep Tabs, the indent must
-			// remain the same.
-			for (p += lead_repl_len; p < leader + lead_len; ++p)
-			    if (!VIM_ISWHITE(*p))
-			    {
-				// Don't put a space before a TAB.
-				if (p + 1 < leader + lead_len && p[1] == TAB)
-				{
-				    --lead_len;
-				    mch_memmove(p, p + 1,
-						     (leader + lead_len) - p);
-				}
-				else
-				{
-				    int	    l = (*mb_ptr2len)(p);
-
-				    if (l > 1)
-				    {
-					if (ptr2cells(p) > 1)
-					{
-					    // Replace a double-wide char with
-					    // two spaces
-					    --l;
-					    *p++ = ' ';
-					}
-					mch_memmove(p + 1, p + l,
-						     (leader + lead_len) - p);
-					lead_len -= l - 1;
-				    }
-				    *p = ' ';
-				}
-			    }
-			*p = NUL;
-		    }
-
-		    // Recompute the indent, it may have changed.
-		    if (curbuf->b_p_ai
-#ifdef FEAT_SMARTINDENT
-					|| do_si
-#endif
-							   )
-#ifdef FEAT_VARTABS
-			newindent = get_indent_str_vtab(leader, curbuf->b_p_ts,
-						 curbuf->b_p_vts_array, FALSE);
-#else
-			newindent = get_indent_str(leader,
-						   (int)curbuf->b_p_ts, FALSE);
-#endif
-
-		    // Add the indent offset
-		    if (newindent + off < 0)
-		    {
-			off = -newindent;
-			newindent = 0;
-		    }
-		    else
-			newindent += off;
-
-		    // Correct trailing spaces for the shift, so that
-		    // alignment remains equal.
-		    while (off > 0 && lead_len > 0
-					       && leader[lead_len - 1] == ' ')
-		    {
-			// Don't do it when there is a tab before the space
-			if (vim_strchr(skipwhite(leader), '\t') != NULL)
-			    break;
-			--lead_len;
-			--off;
-		    }
-
-		    // If the leader ends in white space, don't add an
-		    // extra space
-		    if (lead_len > 0 && VIM_ISWHITE(leader[lead_len - 1]))
-			extra_space = FALSE;
-		    leader[lead_len] = NUL;
-		}
-
-		if (extra_space)
-		{
-		    leader[lead_len++] = ' ';
-		    leader[lead_len] = NUL;
-		}
-
-		newcol = lead_len;
-
-		// if a new indent will be set below, remove the indent that
-		// is in the comment leader
-		if (newindent
-#ifdef FEAT_SMARTINDENT
-				|| did_si
-#endif
-					   )
-		{
-		    while (lead_len && VIM_ISWHITE(*leader))
-		    {
-			--lead_len;
-			--newcol;
-			++leader;
-		    }
-		}
-
-	    }
-#ifdef FEAT_SMARTINDENT
-	    did_si = can_si = FALSE;
-#endif
-	}
-	else if (comment_end != NULL)
-	{
-	    // We have finished a comment, so we don't use the leader.
-	    // If this was a C-comment and 'ai' or 'si' is set do a normal
-	    // indent to align with the line containing the start of the
-	    // comment.
-	    if (comment_end[0] == '*' && comment_end[1] == '/' &&
-			(curbuf->b_p_ai
-#ifdef FEAT_SMARTINDENT
-					|| do_si
-#endif
-							   ))
-	    {
-		old_cursor = curwin->w_cursor;
-		curwin->w_cursor.col = (colnr_T)(comment_end - saved_line);
-		if ((pos = findmatch(NULL, NUL)) != NULL)
-		{
-		    curwin->w_cursor.lnum = pos->lnum;
-		    newindent = get_indent();
-		}
-		curwin->w_cursor = old_cursor;
-	    }
-	}
+  u_clearline();                // cannot do "U" command when adding lines
+  did_si = false;
+  ai_col = 0;
+
+  /*
+   * If we just did an auto-indent, then we didn't type anything on
+   * the prior line, and it should be truncated.  Do this even if 'ai' is not
+   * set because automatically inserting a comment leader also sets did_ai.
+   */
+  if (dir == FORWARD && did_ai)
+    trunc_line = TRUE;
+
+  /*
+   * If 'autoindent' and/or 'smartindent' is set, try to figure out what
+   * indent to use for the new line.
+   */
+  if (curbuf->b_p_ai
+      || do_si
+      ) {
+    // count white space on current line
+    newindent = get_indent_str(saved_line, (int)curbuf->b_p_ts, false);
+    if (newindent == 0 && !(flags & OPENLINE_COM_LIST)) {
+      newindent = second_line_indent;  // for ^^D command in insert mode
     }
-#endif
 
-    // (State == INSERT || State == REPLACE), only when dir == FORWARD
-    if (p_extra != NULL)
-    {
-	*p_extra = saved_char;		// restore char that NUL replaced
-
-	// When 'ai' set or "flags" has OPENLINE_DELSPACES, skip to the first
-	// non-blank.
-	//
-	// When in REPLACE mode, put the deleted blanks on the replace stack,
-	// preceded by a NUL, so they can be put back when a BS is entered.
-	if (REPLACE_NORMAL(State))
-	    replace_push(NUL);	    /* end of extra blanks */
-	if (curbuf->b_p_ai || (flags & OPENLINE_DELSPACES))
-	{
-	    while ((*p_extra == ' ' || *p_extra == '\t')
-		    && (!enc_utf8
-			       || !utf_iscomposing(utf_ptr2char(p_extra + 1))))
-	    {
-		if (REPLACE_NORMAL(State))
-		    replace_push(*p_extra);
-		++p_extra;
-		++less_cols_off;
-	    }
-	}
-
-	// columns for marks adjusted for removed columns
-	less_cols = (int)(p_extra - saved_line);
+    /*
+     * Do smart indenting.
+     * In insert/replace mode (only when dir == FORWARD)
+     * we may move some text to the next line. If it starts with '{'
+     * don't add an indent. Fixes inserting a NL before '{' in line
+     *	"if (condition) {"
+     */
+    if (!trunc_line && do_si && *saved_line != NUL
+        && (p_extra == NULL || first_char != '{')) {
+      char_u  *ptr;
+      char_u last_char;
+
+      old_cursor = curwin->w_cursor;
+      ptr = saved_line;
+      if (flags & OPENLINE_DO_COM)
+        lead_len = get_leader_len(ptr, NULL, FALSE, TRUE);
+      else
+        lead_len = 0;
+      if (dir == FORWARD) {
+        // Skip preprocessor directives, unless they are
+        // recognised as comments.
+        if (lead_len == 0 && ptr[0] == '#') {
+          while (ptr[0] == '#' && curwin->w_cursor.lnum > 1) {
+            ptr = ml_get(--curwin->w_cursor.lnum);
+          }
+          newindent = get_indent();
+        }
+        if (flags & OPENLINE_DO_COM)
+          lead_len = get_leader_len(ptr, NULL, FALSE, TRUE);
+        else
+          lead_len = 0;
+        if (lead_len > 0) {
+          /*
+           * This case gets the following right:
+           *	    \*
+           *	     * A comment (read '\' as '/').
+           *	     *\
+           * #define IN_THE_WAY
+           *	    This should line up here;
+           */
+          p = skipwhite(ptr);
+          if (p[0] == '/' && p[1] == '*')
+            p++;
+          if (p[0] == '*') {
+            for (p++; *p; p++) {
+              if (p[0] == '/' && p[-1] == '*') {
+                /*
+                 * End of C comment, indent should line up
+                 * with the line containing the start of
+                 * the comment
+                 */
+                curwin->w_cursor.col = (colnr_T)(p - ptr);
+                if ((pos = findmatch(NULL, NUL)) != NULL) {
+                  curwin->w_cursor.lnum = pos->lnum;
+                  newindent = get_indent();
+                }
+              }
+            }
+          }
+        } else {      /* Not a comment line */
+          /* Find last non-blank in line */
+          p = ptr + STRLEN(ptr) - 1;
+          while (p > ptr && ascii_iswhite(*p))
+            --p;
+          last_char = *p;
+
+          /*
+           * find the character just before the '{' or ';'
+           */
+          if (last_char == '{' || last_char == ';') {
+            if (p > ptr)
+              --p;
+            while (p > ptr && ascii_iswhite(*p))
+              --p;
+          }
+          /*
+           * Try to catch lines that are split over multiple
+           * lines.  eg:
+           *	    if (condition &&
+           *			condition) {
+           *		Should line up here!
+           *	    }
+           */
+          if (*p == ')') {
+            curwin->w_cursor.col = (colnr_T)(p - ptr);
+            if ((pos = findmatch(NULL, '(')) != NULL) {
+              curwin->w_cursor.lnum = pos->lnum;
+              newindent = get_indent();
+              ptr = get_cursor_line_ptr();
+            }
+          }
+          /*
+           * If last character is '{' do indent, without
+           * checking for "if" and the like.
+           */
+          if (last_char == '{') {
+            did_si = true;              // do indent
+            no_si = true;               // don't delete it when '{' typed
+          }
+          /*
+           * Look for "if" and the like, use 'cinwords'.
+           * Don't do this if the previous line ended in ';' or
+           * '}'.
+           */
+          else if (last_char != ';' && last_char != '}'
+                   && cin_is_cinword(ptr))
+            did_si = true;
+        }
+      } else {  // dir == BACKWARD
+        // Skip preprocessor directives, unless they are
+        // recognised as comments.
+        if (lead_len == 0 && ptr[0] == '#') {
+          bool was_backslashed = false;
+
+          while ((ptr[0] == '#' || was_backslashed)
+                 && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) {
+            if (*ptr && ptr[STRLEN(ptr) - 1] == '\\') {
+              was_backslashed = true;
+            } else {
+              was_backslashed = false;
+            }
+            ptr = ml_get(++curwin->w_cursor.lnum);
+          }
+          if (was_backslashed) {
+            newindent = 0;  // Got to end of file
+          } else {
+            newindent = get_indent();
+          }
+        }
+        p = skipwhite(ptr);
+        if (*p == '}') {            // if line starts with '}': do indent
+          did_si = true;
+        } else {                    // can delete indent when '{' typed
+          can_si_back = true;
+        }
+      }
+      curwin->w_cursor = old_cursor;
+    }
+    if (do_si) {
+      can_si = true;
     }
 
-    if (p_extra == NULL)
-	p_extra = (char_u *)"";		    // append empty line
+    did_ai = true;
+  }
 
-#ifdef FEAT_COMMENTS
-    // concatenate leader and p_extra, if there is a leader
-    if (lead_len)
-    {
-	if (flags & OPENLINE_COM_LIST && second_line_indent > 0)
-	{
-	    int i;
-	    int padding = second_line_indent
-					  - (newindent + (int)STRLEN(leader));
-
-	    // Here whitespace is inserted after the comment char.
-	    // Below, set_indent(newindent, SIN_INSERT) will insert the
-	    // whitespace needed before the comment char.
-	    for (i = 0; i < padding; i++)
-	    {
-		STRCAT(leader, " ");
-		less_cols--;
-		newcol++;
-	    }
-	}
-	STRCAT(leader, p_extra);
-	p_extra = leader;
-	did_ai = TRUE;	    // So truncating blanks works with comments
-	less_cols -= lead_len;
-    }
-    else
-	end_comment_pending = NUL;  // turns out there was no leader
-#endif
+  /*
+   * Find out if the current line starts with a comment leader.
+   * This may then be inserted in front of the new line.
+   */
+  end_comment_pending = NUL;
+  if (flags & OPENLINE_DO_COM)
+    lead_len = get_leader_len(saved_line, &lead_flags, dir == BACKWARD, TRUE);
+  else
+    lead_len = 0;
+  if (lead_len > 0) {
+    char_u  *lead_repl = NULL;              /* replaces comment leader */
+    int lead_repl_len = 0;                  /* length of *lead_repl */
+    char_u lead_middle[COM_MAX_LEN];        /* middle-comment string */
+    char_u lead_end[COM_MAX_LEN];           /* end-comment string */
+    char_u  *comment_end = NULL;            /* where lead_end has been found */
+    int extra_space = FALSE;                /* append extra space */
+    int current_flag;
+    int require_blank = FALSE;              /* requires blank after middle */
+    char_u  *p2;
 
-    old_cursor = curwin->w_cursor;
-    if (dir == BACKWARD)
-	--curwin->w_cursor.lnum;
-    if (!(State & VREPLACE_FLAG) || old_cursor.lnum >= orig_line_count)
-    {
-	if (ml_append(curwin->w_cursor.lnum, p_extra, (colnr_T)0, FALSE)
-								      == FAIL)
-	    goto theend;
-	// Postpone calling changed_lines(), because it would mess up folding
-	// with markers.
-	// Skip mark_adjust when adding a line after the last one, there can't
-	// be marks there. But still needed in diff mode.
-	if (curwin->w_cursor.lnum + 1 < curbuf->b_ml.ml_line_count
-#ifdef FEAT_DIFF
-		|| curwin->w_p_diff
-#endif
-	    )
-	    mark_adjust(curwin->w_cursor.lnum + 1, (linenr_T)MAXLNUM, 1L, 0L);
-	did_append = TRUE;
-    }
-    else
-    {
-	// In VREPLACE mode we are starting to replace the next line.
-	curwin->w_cursor.lnum++;
-	if (curwin->w_cursor.lnum >= Insstart.lnum + vr_lines_changed)
-	{
-	    // In case we NL to a new line, BS to the previous one, and NL
-	    // again, we don't want to save the new line for undo twice.
-	    (void)u_save_cursor();		    /* errors are ignored! */
-	    vr_lines_changed++;
-	}
-	ml_replace(curwin->w_cursor.lnum, p_extra, TRUE);
-	changed_bytes(curwin->w_cursor.lnum, 0);
-	curwin->w_cursor.lnum--;
-	did_append = FALSE;
+    /*
+     * If the comment leader has the start, middle or end flag, it may not
+     * be used or may be replaced with the middle leader.
+     */
+    for (p = lead_flags; *p && *p != ':'; ++p) {
+      if (*p == COM_BLANK) {
+        require_blank = TRUE;
+        continue;
+      }
+      if (*p == COM_START || *p == COM_MIDDLE) {
+        current_flag = *p;
+        if (*p == COM_START) {
+          /*
+           * Doing "O" on a start of comment does not insert leader.
+           */
+          if (dir == BACKWARD) {
+            lead_len = 0;
+            break;
+          }
+
+          /* find start of middle part */
+          (void)copy_option_part(&p, lead_middle, COM_MAX_LEN, ",");
+          require_blank = FALSE;
+        }
+
+        /*
+         * Isolate the strings of the middle and end leader.
+         */
+        while (*p && p[-1] != ':') {            /* find end of middle flags */
+          if (*p == COM_BLANK)
+            require_blank = TRUE;
+          ++p;
+        }
+        (void)copy_option_part(&p, lead_middle, COM_MAX_LEN, ",");
+
+        while (*p && p[-1] != ':') {            /* find end of end flags */
+          /* Check whether we allow automatic ending of comments */
+          if (*p == COM_AUTO_END)
+            end_comment_pending = -1;             /* means we want to set it */
+          ++p;
+        }
+        size_t n = copy_option_part(&p, lead_end, COM_MAX_LEN, ",");
+
+        if (end_comment_pending == -1)          /* we can set it now */
+          end_comment_pending = lead_end[n - 1];
+
+        /*
+         * If the end of the comment is in the same line, don't use
+         * the comment leader.
+         */
+        if (dir == FORWARD) {
+          for (p = saved_line + lead_len; *p; ++p)
+            if (STRNCMP(p, lead_end, n) == 0) {
+              comment_end = p;
+              lead_len = 0;
+              break;
+            }
+        }
+
+        /*
+         * Doing "o" on a start of comment inserts the middle leader.
+         */
+        if (lead_len > 0) {
+          if (current_flag == COM_START) {
+            lead_repl = lead_middle;
+            lead_repl_len = (int)STRLEN(lead_middle);
+          }
+
+          /*
+           * If we have hit RETURN immediately after the start
+           * comment leader, then put a space after the middle
+           * comment leader on the next line.
+           */
+          if (!ascii_iswhite(saved_line[lead_len - 1])
+              && ((p_extra != NULL
+                   && (int)curwin->w_cursor.col == lead_len)
+                  || (p_extra == NULL
+                      && saved_line[lead_len] == NUL)
+                  || require_blank))
+            extra_space = TRUE;
+        }
+        break;
+      }
+      if (*p == COM_END) {
+        /*
+         * Doing "o" on the end of a comment does not insert leader.
+         * Remember where the end is, might want to use it to find the
+         * start (for C-comments).
+         */
+        if (dir == FORWARD) {
+          comment_end = skipwhite(saved_line);
+          lead_len = 0;
+          break;
+        }
+
+        /*
+         * Doing "O" on the end of a comment inserts the middle leader.
+         * Find the string for the middle leader, searching backwards.
+         */
+        while (p > curbuf->b_p_com && *p != ',')
+          --p;
+        for (lead_repl = p; lead_repl > curbuf->b_p_com
+             && lead_repl[-1] != ':'; --lead_repl)
+          ;
+        lead_repl_len = (int)(p - lead_repl);
+
+        /* We can probably always add an extra space when doing "O" on
+         * the comment-end */
+        extra_space = TRUE;
+
+        /* Check whether we allow automatic ending of comments */
+        for (p2 = p; *p2 && *p2 != ':'; p2++) {
+          if (*p2 == COM_AUTO_END)
+            end_comment_pending = -1;             /* means we want to set it */
+        }
+        if (end_comment_pending == -1) {
+          /* Find last character in end-comment string */
+          while (*p2 && *p2 != ',')
+            p2++;
+          end_comment_pending = p2[-1];
+        }
+        break;
+      }
+      if (*p == COM_FIRST) {
+        /*
+         * Comment leader for first line only:	Don't repeat leader
+         * when using "O", blank out leader when using "o".
+         */
+        if (dir == BACKWARD)
+          lead_len = 0;
+        else {
+          lead_repl = (char_u *)"";
+          lead_repl_len = 0;
+        }
+        break;
+      }
     }
+    if (lead_len > 0) {
+      // allocate buffer (may concatenate p_extra later)
+      int bytes = lead_len
+          + lead_repl_len
+          + extra_space
+          + extra_len
+          + (second_line_indent > 0 ? second_line_indent : 0)
+          + 1;
+      assert(bytes >= 0);
+      leader = xmalloc((size_t)bytes);
+      allocated = leader;  // remember to free it later
+
+      STRLCPY(leader, saved_line, lead_len + 1);
 
-    if (newindent
-#ifdef FEAT_SMARTINDENT
-		    || did_si
-#endif
-				)
-    {
-	++curwin->w_cursor.lnum;
-#ifdef FEAT_SMARTINDENT
-	if (did_si)
-	{
-	    int sw = (int)get_sw_value(curbuf);
-
-	    if (p_sr)
-		newindent -= newindent % sw;
-	    newindent += sw;
-	}
-#endif
-	// Copy the indent
-	if (curbuf->b_p_ci)
-	{
-	    (void)copy_indent(newindent, saved_line);
-
-	    // Set the 'preserveindent' option so that any further screwing
-	    // with the line doesn't entirely destroy our efforts to preserve
-	    // it.  It gets restored at the function end.
-	    curbuf->b_p_pi = TRUE;
-	}
-	else
-	    (void)set_indent(newindent, SIN_INSERT);
-	less_cols -= curwin->w_cursor.col;
-
-	ai_col = curwin->w_cursor.col;
-
-	// In REPLACE mode, for each character in the new indent, there must
-	// be a NUL on the replace stack, for when it is deleted with BS
-	if (REPLACE_NORMAL(State))
-	    for (n = 0; n < (int)curwin->w_cursor.col; ++n)
-		replace_push(NUL);
-	newcol += curwin->w_cursor.col;
-#ifdef FEAT_SMARTINDENT
-	if (no_si)
-	    did_si = FALSE;
-#endif
+      /*
+       * Replace leader with lead_repl, right or left adjusted
+       */
+      if (lead_repl != NULL) {
+        int c = 0;
+        int off = 0;
+
+        for (p = lead_flags; *p != NUL && *p != ':'; ) {
+          if (*p == COM_RIGHT || *p == COM_LEFT)
+            c = *p++;
+          else if (ascii_isdigit(*p) || *p == '-')
+            off = getdigits_int(&p);
+          else
+            ++p;
+        }
+        if (c == COM_RIGHT) {            /* right adjusted leader */
+          /* find last non-white in the leader to line up with */
+          for (p = leader + lead_len - 1; p > leader
+               && ascii_iswhite(*p); --p)
+            ;
+          ++p;
+
+          /* Compute the length of the replaced characters in
+           * screen characters, not bytes. */
+          {
+            int repl_size = vim_strnsize(lead_repl,
+                lead_repl_len);
+            int old_size = 0;
+            char_u  *endp = p;
+            int l;
+
+            while (old_size < repl_size && p > leader) {
+              MB_PTR_BACK(leader, p);
+              old_size += ptr2cells(p);
+            }
+            l = lead_repl_len - (int)(endp - p);
+            if (l != 0)
+              memmove(endp + l, endp,
+                  (size_t)((leader + lead_len) - endp));
+            lead_len += l;
+          }
+          memmove(p, lead_repl, (size_t)lead_repl_len);
+          if (p + lead_repl_len > leader + lead_len)
+            p[lead_repl_len] = NUL;
+
+          /* blank-out any other chars from the old leader. */
+          while (--p >= leader) {
+            int l = utf_head_off(leader, p);
+
+            if (l > 1) {
+              p -= l;
+              if (ptr2cells(p) > 1) {
+                p[1] = ' ';
+                --l;
+              }
+              memmove(p + 1, p + l + 1,
+                  (size_t)((leader + lead_len) - (p + l + 1)));
+              lead_len -= l;
+              *p = ' ';
+            } else if (!ascii_iswhite(*p))
+              *p = ' ';
+          }
+        } else {                        /* left adjusted leader */
+          p = skipwhite(leader);
+          /* Compute the length of the replaced characters in
+           * screen characters, not bytes. Move the part that is
+           * not to be overwritten. */
+          {
+            int repl_size = vim_strnsize(lead_repl,
+                lead_repl_len);
+            int i;
+            int l;
+
+            for (i = 0; i < lead_len && p[i] != NUL; i += l) {
+              l = (*mb_ptr2len)(p + i);
+              if (vim_strnsize(p, i + l) > repl_size)
+                break;
+            }
+            if (i != lead_repl_len) {
+              memmove(p + lead_repl_len, p + i,
+                  (size_t)(lead_len - i - (p - leader)));
+              lead_len += lead_repl_len - i;
+            }
+          }
+          memmove(p, lead_repl, (size_t)lead_repl_len);
+
+          /* Replace any remaining non-white chars in the old
+           * leader by spaces.  Keep Tabs, the indent must
+           * remain the same. */
+          for (p += lead_repl_len; p < leader + lead_len; ++p)
+            if (!ascii_iswhite(*p)) {
+              /* Don't put a space before a TAB. */
+              if (p + 1 < leader + lead_len && p[1] == TAB) {
+                lead_len--;
+                memmove(p, p + 1, (size_t)(leader + lead_len - p));
+              } else {
+                int l = (*mb_ptr2len)(p);
+
+                if (l > 1) {
+                  if (ptr2cells(p) > 1) {
+                    /* Replace a double-wide char with
+                     * two spaces */
+                    --l;
+                    *p++ = ' ';
+                  }
+                  memmove(p + 1, p + l, (size_t)(leader + lead_len - p));
+                  lead_len -= l - 1;
+                }
+                *p = ' ';
+              }
+            }
+          *p = NUL;
+        }
+
+        /* Recompute the indent, it may have changed. */
+        if (curbuf->b_p_ai
+            || do_si
+            )
+          newindent = get_indent_str(leader, (int)curbuf->b_p_ts, false);
+
+        /* Add the indent offset */
+        if (newindent + off < 0) {
+          off = -newindent;
+          newindent = 0;
+        } else
+          newindent += off;
+
+        /* Correct trailing spaces for the shift, so that
+         * alignment remains equal. */
+        while (off > 0 && lead_len > 0
+               && leader[lead_len - 1] == ' ') {
+          /* Don't do it when there is a tab before the space */
+          if (vim_strchr(skipwhite(leader), '\t') != NULL)
+            break;
+          --lead_len;
+          --off;
+        }
+
+        /* If the leader ends in white space, don't add an
+         * extra space */
+        if (lead_len > 0 && ascii_iswhite(leader[lead_len - 1]))
+          extra_space = FALSE;
+        leader[lead_len] = NUL;
+      }
+
+      if (extra_space) {
+        leader[lead_len++] = ' ';
+        leader[lead_len] = NUL;
+      }
+
+      newcol = lead_len;
+
+      /*
+       * if a new indent will be set below, remove the indent that
+       * is in the comment leader
+       */
+      if (newindent
+          || did_si
+          ) {
+        while (lead_len && ascii_iswhite(*leader)) {
+          --lead_len;
+          --newcol;
+          ++leader;
+        }
+      }
+
+      did_si = can_si = false;
+    } else if (comment_end != NULL) {
+      // We have finished a comment, so we don't use the leader.
+      // If this was a C-comment and 'ai' or 'si' is set do a normal
+      // indent to align with the line containing the start of the
+      // comment.
+      if (comment_end[0] == '*' && comment_end[1] == '/'
+          && (curbuf->b_p_ai || do_si)) {
+        old_cursor = curwin->w_cursor;
+        curwin->w_cursor.col = (colnr_T)(comment_end - saved_line);
+        if ((pos = findmatch(NULL, NUL)) != NULL) {
+          curwin->w_cursor.lnum = pos->lnum;
+          newindent = get_indent();
+        }
+        curwin->w_cursor = old_cursor;
+      }
     }
+  }
+
+  /* (State == INSERT || State == REPLACE), only when dir == FORWARD */
+  if (p_extra != NULL) {
+    *p_extra = saved_char;              /* restore char that NUL replaced */
 
-#ifdef FEAT_COMMENTS
-    // In REPLACE mode, for each character in the extra leader, there must be
-    // a NUL on the replace stack, for when it is deleted with BS.
+    /*
+     * When 'ai' set or "flags" has OPENLINE_DELSPACES, skip to the first
+     * non-blank.
+     *
+     * When in REPLACE mode, put the deleted blanks on the replace stack,
+     * preceded by a NUL, so they can be put back when a BS is entered.
+     */
     if (REPLACE_NORMAL(State))
-	while (lead_len-- > 0)
-	    replace_push(NUL);
-#endif
+      replace_push(NUL);            /* end of extra blanks */
+    if (curbuf->b_p_ai || (flags & OPENLINE_DELSPACES)) {
+      while ((*p_extra == ' ' || *p_extra == '\t')
+             && !utf_iscomposing(utf_ptr2char(p_extra + 1))) {
+        if (REPLACE_NORMAL(State)) {
+          replace_push(*p_extra);
+        }
+        p_extra++;
+        less_cols_off++;
+      }
+    }
 
-    curwin->w_cursor = old_cursor;
+    /* columns for marks adjusted for removed columns */
+    less_cols = (int)(p_extra - saved_line);
+  }
 
-    if (dir == FORWARD)
-    {
-	if (trunc_line || (State & INSERT))
-	{
-	    // truncate current line at cursor
-	    saved_line[curwin->w_cursor.col] = NUL;
-	    // Remove trailing white space, unless OPENLINE_KEEPTRAIL used.
-	    if (trunc_line && !(flags & OPENLINE_KEEPTRAIL))
-		truncate_spaces(saved_line);
-	    ml_replace(curwin->w_cursor.lnum, saved_line, FALSE);
-	    saved_line = NULL;
-	    if (did_append)
-	    {
-		changed_lines(curwin->w_cursor.lnum, curwin->w_cursor.col,
-					       curwin->w_cursor.lnum + 1, 1L);
-		did_append = FALSE;
-
-		// Move marks after the line break to the new line.
-		if (flags & OPENLINE_MARKFIX)
-		    mark_col_adjust(curwin->w_cursor.lnum,
-					 curwin->w_cursor.col + less_cols_off,
-						      1L, (long)-less_cols, 0);
-	    }
-	    else
-		changed_bytes(curwin->w_cursor.lnum, curwin->w_cursor.col);
-	}
-
-	// Put the cursor on the new line.  Careful: the scrollup() above may
-	// have moved w_cursor, we must use old_cursor.
-	curwin->w_cursor.lnum = old_cursor.lnum + 1;
+  if (p_extra == NULL)
+    p_extra = (char_u *)"";                 /* append empty line */
+
+  /* concatenate leader and p_extra, if there is a leader */
+  if (lead_len > 0) {
+    if (flags & OPENLINE_COM_LIST && second_line_indent > 0) {
+      int i;
+      int padding = second_line_indent
+                    - (newindent + (int)STRLEN(leader));
+
+      /* Here whitespace is inserted after the comment char.
+       * Below, set_indent(newindent, SIN_INSERT) will insert the
+       * whitespace needed before the comment char. */
+      for (i = 0; i < padding; i++) {
+        STRCAT(leader, " ");
+        less_cols--;
+        newcol++;
+      }
+    }
+    STRCAT(leader, p_extra);
+    p_extra = leader;
+    did_ai = true;          // So truncating blanks works with comments
+    less_cols -= lead_len;
+  } else
+    end_comment_pending = NUL;      /* turns out there was no leader */
+
+  old_cursor = curwin->w_cursor;
+  if (dir == BACKWARD)
+    --curwin->w_cursor.lnum;
+  if (!(State & VREPLACE_FLAG) || old_cursor.lnum >= orig_line_count) {
+    if (ml_append(curwin->w_cursor.lnum, p_extra, (colnr_T)0, false) == FAIL) {
+      goto theend;
     }
-    if (did_append)
-	changed_lines(curwin->w_cursor.lnum, 0, curwin->w_cursor.lnum, 1L);
+    // Postpone calling changed_lines(), because it would mess up folding
+    // with markers.
+    // Skip mark_adjust when adding a line after the last one, there can't
+    // be marks there. But still needed in diff mode.
+    if (curwin->w_cursor.lnum + 1 < curbuf->b_ml.ml_line_count
+        || curwin->w_p_diff) {
+      mark_adjust(curwin->w_cursor.lnum + 1, (linenr_T)MAXLNUM, 1L, 0L, false);
+    }
+    did_append = true;
+  } else {
+    /*
+     * In VREPLACE mode we are starting to replace the next line.
+     */
+    curwin->w_cursor.lnum++;
+    if (curwin->w_cursor.lnum >= Insstart.lnum + vr_lines_changed) {
+      /* In case we NL to a new line, BS to the previous one, and NL
+       * again, we don't want to save the new line for undo twice.
+       */
+      (void)u_save_cursor();                        /* errors are ignored! */
+      vr_lines_changed++;
+    }
+    ml_replace(curwin->w_cursor.lnum, p_extra, true);
+    changed_bytes(curwin->w_cursor.lnum, 0);
+    curwin->w_cursor.lnum--;
+    did_append = FALSE;
+  }
 
-    curwin->w_cursor.col = newcol;
-    curwin->w_cursor.coladd = 0;
+  inhibit_delete_count++;
+  if (newindent
+      || did_si
+      ) {
+    ++curwin->w_cursor.lnum;
+    if (did_si) {
+      int sw = get_sw_value(curbuf);
 
-#if defined(FEAT_LISP) || defined(FEAT_CINDENT)
-    // In VREPLACE mode, we are handling the replace stack ourselves, so stop
-    // fixthisline() from doing it (via change_indent()) by telling it we're in
-    // normal INSERT mode.
-    if (State & VREPLACE_FLAG)
-    {
-	vreplace_mode = State;	// So we know to put things right later
-	State = INSERT;
+      if (p_sr)
+        newindent -= newindent % sw;
+      newindent += sw;
     }
-    else
-	vreplace_mode = 0;
-#endif
-#ifdef FEAT_LISP
-    // May do lisp indenting.
-    if (!p_paste
-# ifdef FEAT_COMMENTS
-	    && leader == NULL
-# endif
-	    && curbuf->b_p_lisp
-	    && curbuf->b_p_ai)
-    {
-	fixthisline(get_lisp_indent);
-	ai_col = (colnr_T)getwhitecols_curline();
+    /* Copy the indent */
+    if (curbuf->b_p_ci) {
+      (void)copy_indent(newindent, saved_line);
+
+      /*
+       * Set the 'preserveindent' option so that any further screwing
+       * with the line doesn't entirely destroy our efforts to preserve
+       * it.  It gets restored at the function end.
+       */
+      curbuf->b_p_pi = TRUE;
+    } else
+      (void)set_indent(newindent, SIN_INSERT);
+    less_cols -= curwin->w_cursor.col;
+
+    ai_col = curwin->w_cursor.col;
+
+    /*
+     * In REPLACE mode, for each character in the new indent, there must
+     * be a NUL on the replace stack, for when it is deleted with BS
+     */
+    if (REPLACE_NORMAL(State)) {
+      for (colnr_T n = 0; n < curwin->w_cursor.col; n++) {
+        replace_push(NUL);
+      }
     }
-#endif
-#ifdef FEAT_CINDENT
-    // May do indenting after opening a new line.
-    if (!p_paste
-	    && (curbuf->b_p_cin
-#  ifdef FEAT_EVAL
-		    || *curbuf->b_p_inde != NUL
-#  endif
-		)
-	    && in_cinkeys(dir == FORWARD
-		? KEY_OPEN_FORW
-		: KEY_OPEN_BACK, ' ', linewhite(curwin->w_cursor.lnum)))
-    {
-	do_c_expr_indent();
-	ai_col = (colnr_T)getwhitecols_curline();
+    newcol += curwin->w_cursor.col;
+    if (no_si) {
+      did_si = false;
     }
-#endif
-#if defined(FEAT_LISP) || defined(FEAT_CINDENT)
-    if (vreplace_mode != 0)
-	State = vreplace_mode;
-#endif
-
-    // Finally, VREPLACE gets the stuff on the new line, then puts back the
-    // original line, and inserts the new stuff char by char, pushing old stuff
-    // onto the replace stack (via ins_char()).
-    if (State & VREPLACE_FLAG)
-    {
-	// Put new line in p_extra
-	p_extra = vim_strsave(ml_get_curline());
-	if (p_extra == NULL)
-	    goto theend;
-
-	// Put back original line
-	ml_replace(curwin->w_cursor.lnum, next_line, FALSE);
-
-	// Insert new stuff into line again
-	curwin->w_cursor.col = 0;
-	curwin->w_cursor.coladd = 0;
-	ins_bytes(p_extra);	// will call changed_bytes()
-	vim_free(p_extra);
-	next_line = NULL;
+  }
+  inhibit_delete_count--;
+
+  /*
+   * In REPLACE mode, for each character in the extra leader, there must be
+   * a NUL on the replace stack, for when it is deleted with BS.
+   */
+  if (REPLACE_NORMAL(State))
+    while (lead_len-- > 0)
+      replace_push(NUL);
+
+  curwin->w_cursor = old_cursor;
+
+  if (dir == FORWARD) {
+    if (trunc_line || (State & INSERT)) {
+      // truncate current line at cursor
+      saved_line[curwin->w_cursor.col] = NUL;
+      // Remove trailing white space, unless OPENLINE_KEEPTRAIL used.
+      if (trunc_line && !(flags & OPENLINE_KEEPTRAIL)) {
+        truncate_spaces(saved_line);
+      }
+      ml_replace(curwin->w_cursor.lnum, saved_line, false);
+      saved_line = NULL;
+      if (did_append) {
+        changed_lines(curwin->w_cursor.lnum, curwin->w_cursor.col,
+                      curwin->w_cursor.lnum + 1, 1L, true);
+        did_append = false;
+
+        /* Move marks after the line break to the new line. */
+        if (flags & OPENLINE_MARKFIX)
+          mark_col_adjust(curwin->w_cursor.lnum,
+                          curwin->w_cursor.col + less_cols_off,
+                          1L, (long)-less_cols, 0);
+      } else {
+        changed_bytes(curwin->w_cursor.lnum, curwin->w_cursor.col);
+      }
     }
 
-    retval = OK;		// success!
+    /*
+     * Put the cursor on the new line.  Careful: the scrollup() above may
+     * have moved w_cursor, we must use old_cursor.
+     */
+    curwin->w_cursor.lnum = old_cursor.lnum + 1;
+  }
+  if (did_append) {
+    changed_lines(curwin->w_cursor.lnum, 0, curwin->w_cursor.lnum, 1L, true);
+  }
+
+  curwin->w_cursor.col = newcol;
+  curwin->w_cursor.coladd = 0;
+
+  /*
+   * In VREPLACE mode, we are handling the replace stack ourselves, so stop
+   * fixthisline() from doing it (via change_indent()) by telling it we're in
+   * normal INSERT mode.
+   */
+  if (State & VREPLACE_FLAG) {
+    vreplace_mode = State;      /* So we know to put things right later */
+    State = INSERT;
+  } else
+    vreplace_mode = 0;
+  /*
+   * May do lisp indenting.
+   */
+  if (!p_paste
+      && leader == NULL
+      && curbuf->b_p_lisp
+      && curbuf->b_p_ai) {
+    fixthisline(get_lisp_indent);
+    ai_col = (colnr_T)getwhitecols_curline();
+  }
+  /*
+   * May do indenting after opening a new line.
+   */
+  if (!p_paste
+      && (curbuf->b_p_cin
+          || *curbuf->b_p_inde != NUL
+          )
+      && in_cinkeys(dir == FORWARD
+          ? KEY_OPEN_FORW
+          : KEY_OPEN_BACK, ' ', linewhite(curwin->w_cursor.lnum))) {
+    do_c_expr_indent();
+    ai_col = (colnr_T)getwhitecols_curline();
+  }
+  if (vreplace_mode != 0)
+    State = vreplace_mode;
+
+  /*
+   * Finally, VREPLACE gets the stuff on the new line, then puts back the
+   * original line, and inserts the new stuff char by char, pushing old stuff
+   * onto the replace stack (via ins_char()).
+   */
+  if (State & VREPLACE_FLAG) {
+    /* Put new line in p_extra */
+    p_extra = vim_strsave(get_cursor_line_ptr());
+
+    // Put back original line
+    ml_replace(curwin->w_cursor.lnum, next_line, false);
+
+    /* Insert new stuff into line again */
+    curwin->w_cursor.col = 0;
+    curwin->w_cursor.coladd = 0;
+    ins_bytes(p_extra);         /* will call changed_bytes() */
+    xfree(p_extra);
+    next_line = NULL;
+  }
+
+  retval = true;                // success!
 theend:
-    curbuf->b_p_pi = saved_pi;
-    vim_free(saved_line);
-    vim_free(next_line);
-    vim_free(allocated);
-    return retval;
+  curbuf->b_p_pi = saved_pi;
+  xfree(saved_line);
+  xfree(next_line);
+  xfree(allocated);
+  return retval;
 }
 
 /*
diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c
index 80d4c6e0f7..a7d3cb9bba 100644
--- a/src/nvim/misc1.c
+++ b/src/nvim/misc1.c
@@ -65,879 +65,6 @@
 static garray_T ga_users = GA_EMPTY_INIT_VALUE;
 
 /*
- * open_line: Add a new line below or above the current line.
- *
- * For VREPLACE mode, we only add a new line when we get to the end of the
- * file, otherwise we just start replacing the next line.
- *
- * Caller must take care of undo.  Since VREPLACE may affect any number of
- * lines however, it may call u_save_cursor() again when starting to change a
- * new line.
- * "flags": OPENLINE_DELSPACES	delete spaces after cursor
- *	    OPENLINE_DO_COM	format comments
- *	    OPENLINE_KEEPTRAIL	keep trailing spaces
- *	    OPENLINE_MARKFIX	adjust mark positions after the line break
- *	    OPENLINE_COM_LIST	format comments with list or 2nd line indent
- *
- * "second_line_indent": indent for after ^^D in Insert mode or if flag
- *			  OPENLINE_COM_LIST
- *
- * Return TRUE for success, FALSE for failure
- */
-int 
-open_line (
-    int dir,                        /* FORWARD or BACKWARD */
-    int flags,
-    int second_line_indent
-)
-{
-  char_u *next_line = NULL;       // copy of the next line
-  char_u *p_extra = NULL;         // what goes to next line
-  colnr_T less_cols = 0;          // less columns for mark in new line
-  colnr_T less_cols_off = 0;      // columns to skip for mark adjust
-  pos_T old_cursor;               // old cursor position
-  colnr_T newcol = 0;             // new cursor column
-  int newindent = 0;              // auto-indent of the new line
-  bool trunc_line = false;        // truncate current line afterwards
-  bool retval = false;            // return value
-  int extra_len = 0;              // length of p_extra string
-  int lead_len;                   // length of comment leader
-  char_u *lead_flags;             // position in 'comments' for comment leader
-  char_u *leader = NULL;          // copy of comment leader
-  char_u *allocated = NULL;       // allocated memory
-  char_u *p;
-  char_u saved_char = NUL;        // init for GCC
-  pos_T *pos;
-  bool do_si = (!p_paste && curbuf->b_p_si && !curbuf->b_p_cin
-                && *curbuf->b_p_inde == NUL);
-  bool no_si = false;             // reset did_si afterwards
-  int first_char = NUL;           // init for GCC
-  int vreplace_mode;
-  bool did_append;                // appended a new line
-  int saved_pi = curbuf->b_p_pi;  // copy of preserveindent setting
-
-  // make a copy of the current line so we can mess with it
-  char_u *saved_line = vim_strsave(get_cursor_line_ptr());
-
-  if (State & VREPLACE_FLAG) {
-    /*
-     * With VREPLACE we make a copy of the next line, which we will be
-     * starting to replace.  First make the new line empty and let vim play
-     * with the indenting and comment leader to its heart's content.  Then
-     * we grab what it ended up putting on the new line, put back the
-     * original line, and call ins_char() to put each new character onto
-     * the line, replacing what was there before and pushing the right
-     * stuff onto the replace stack.  -- webb.
-     */
-    if (curwin->w_cursor.lnum < orig_line_count)
-      next_line = vim_strsave(ml_get(curwin->w_cursor.lnum + 1));
-    else
-      next_line = vim_strsave((char_u *)"");
-
-    /*
-     * In VREPLACE mode, a NL replaces the rest of the line, and starts
-     * replacing the next line, so push all of the characters left on the
-     * line onto the replace stack.  We'll push any other characters that
-     * might be replaced at the start of the next line (due to autoindent
-     * etc) a bit later.
-     */
-    replace_push(NUL);      /* Call twice because BS over NL expects it */
-    replace_push(NUL);
-    p = saved_line + curwin->w_cursor.col;
-    while (*p != NUL) {
-      if (has_mbyte)
-        p += replace_push_mb(p);
-      else
-        replace_push(*p++);
-    }
-    saved_line[curwin->w_cursor.col] = NUL;
-  }
-
-  if ((State & INSERT)
-      && !(State & VREPLACE_FLAG)
-      ) {
-    p_extra = saved_line + curwin->w_cursor.col;
-    if (do_si) {                /* need first char after new line break */
-      p = skipwhite(p_extra);
-      first_char = *p;
-    }
-    extra_len = (int)STRLEN(p_extra);
-    saved_char = *p_extra;
-    *p_extra = NUL;
-  }
-
-  u_clearline();                // cannot do "U" command when adding lines
-  did_si = false;
-  ai_col = 0;
-
-  /*
-   * If we just did an auto-indent, then we didn't type anything on
-   * the prior line, and it should be truncated.  Do this even if 'ai' is not
-   * set because automatically inserting a comment leader also sets did_ai.
-   */
-  if (dir == FORWARD && did_ai)
-    trunc_line = TRUE;
-
-  /*
-   * If 'autoindent' and/or 'smartindent' is set, try to figure out what
-   * indent to use for the new line.
-   */
-  if (curbuf->b_p_ai
-      || do_si
-      ) {
-    // count white space on current line
-    newindent = get_indent_str(saved_line, (int)curbuf->b_p_ts, false);
-    if (newindent == 0 && !(flags & OPENLINE_COM_LIST)) {
-      newindent = second_line_indent;  // for ^^D command in insert mode
-    }
-
-    /*
-     * Do smart indenting.
-     * In insert/replace mode (only when dir == FORWARD)
-     * we may move some text to the next line. If it starts with '{'
-     * don't add an indent. Fixes inserting a NL before '{' in line
-     *	"if (condition) {"
-     */
-    if (!trunc_line && do_si && *saved_line != NUL
-        && (p_extra == NULL || first_char != '{')) {
-      char_u  *ptr;
-      char_u last_char;
-
-      old_cursor = curwin->w_cursor;
-      ptr = saved_line;
-      if (flags & OPENLINE_DO_COM)
-        lead_len = get_leader_len(ptr, NULL, FALSE, TRUE);
-      else
-        lead_len = 0;
-      if (dir == FORWARD) {
-        // Skip preprocessor directives, unless they are
-        // recognised as comments.
-        if (lead_len == 0 && ptr[0] == '#') {
-          while (ptr[0] == '#' && curwin->w_cursor.lnum > 1) {
-            ptr = ml_get(--curwin->w_cursor.lnum);
-          }
-          newindent = get_indent();
-        }
-        if (flags & OPENLINE_DO_COM)
-          lead_len = get_leader_len(ptr, NULL, FALSE, TRUE);
-        else
-          lead_len = 0;
-        if (lead_len > 0) {
-          /*
-           * This case gets the following right:
-           *	    \*
-           *	     * A comment (read '\' as '/').
-           *	     *\
-           * #define IN_THE_WAY
-           *	    This should line up here;
-           */
-          p = skipwhite(ptr);
-          if (p[0] == '/' && p[1] == '*')
-            p++;
-          if (p[0] == '*') {
-            for (p++; *p; p++) {
-              if (p[0] == '/' && p[-1] == '*') {
-                /*
-                 * End of C comment, indent should line up
-                 * with the line containing the start of
-                 * the comment
-                 */
-                curwin->w_cursor.col = (colnr_T)(p - ptr);
-                if ((pos = findmatch(NULL, NUL)) != NULL) {
-                  curwin->w_cursor.lnum = pos->lnum;
-                  newindent = get_indent();
-                }
-              }
-            }
-          }
-        } else {      /* Not a comment line */
-          /* Find last non-blank in line */
-          p = ptr + STRLEN(ptr) - 1;
-          while (p > ptr && ascii_iswhite(*p))
-            --p;
-          last_char = *p;
-
-          /*
-           * find the character just before the '{' or ';'
-           */
-          if (last_char == '{' || last_char == ';') {
-            if (p > ptr)
-              --p;
-            while (p > ptr && ascii_iswhite(*p))
-              --p;
-          }
-          /*
-           * Try to catch lines that are split over multiple
-           * lines.  eg:
-           *	    if (condition &&
-           *			condition) {
-           *		Should line up here!
-           *	    }
-           */
-          if (*p == ')') {
-            curwin->w_cursor.col = (colnr_T)(p - ptr);
-            if ((pos = findmatch(NULL, '(')) != NULL) {
-              curwin->w_cursor.lnum = pos->lnum;
-              newindent = get_indent();
-              ptr = get_cursor_line_ptr();
-            }
-          }
-          /*
-           * If last character is '{' do indent, without
-           * checking for "if" and the like.
-           */
-          if (last_char == '{') {
-            did_si = true;              // do indent
-            no_si = true;               // don't delete it when '{' typed
-          }
-          /*
-           * Look for "if" and the like, use 'cinwords'.
-           * Don't do this if the previous line ended in ';' or
-           * '}'.
-           */
-          else if (last_char != ';' && last_char != '}'
-                   && cin_is_cinword(ptr))
-            did_si = true;
-        }
-      } else {  // dir == BACKWARD
-        // Skip preprocessor directives, unless they are
-        // recognised as comments.
-        if (lead_len == 0 && ptr[0] == '#') {
-          bool was_backslashed = false;
-
-          while ((ptr[0] == '#' || was_backslashed)
-                 && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) {
-            if (*ptr && ptr[STRLEN(ptr) - 1] == '\\') {
-              was_backslashed = true;
-            } else {
-              was_backslashed = false;
-            }
-            ptr = ml_get(++curwin->w_cursor.lnum);
-          }
-          if (was_backslashed) {
-            newindent = 0;  // Got to end of file
-          } else {
-            newindent = get_indent();
-          }
-        }
-        p = skipwhite(ptr);
-        if (*p == '}') {            // if line starts with '}': do indent
-          did_si = true;
-        } else {                    // can delete indent when '{' typed
-          can_si_back = true;
-        }
-      }
-      curwin->w_cursor = old_cursor;
-    }
-    if (do_si) {
-      can_si = true;
-    }
-
-    did_ai = true;
-  }
-
-  /*
-   * Find out if the current line starts with a comment leader.
-   * This may then be inserted in front of the new line.
-   */
-  end_comment_pending = NUL;
-  if (flags & OPENLINE_DO_COM)
-    lead_len = get_leader_len(saved_line, &lead_flags, dir == BACKWARD, TRUE);
-  else
-    lead_len = 0;
-  if (lead_len > 0) {
-    char_u  *lead_repl = NULL;              /* replaces comment leader */
-    int lead_repl_len = 0;                  /* length of *lead_repl */
-    char_u lead_middle[COM_MAX_LEN];        /* middle-comment string */
-    char_u lead_end[COM_MAX_LEN];           /* end-comment string */
-    char_u  *comment_end = NULL;            /* where lead_end has been found */
-    int extra_space = FALSE;                /* append extra space */
-    int current_flag;
-    int require_blank = FALSE;              /* requires blank after middle */
-    char_u  *p2;
-
-    /*
-     * If the comment leader has the start, middle or end flag, it may not
-     * be used or may be replaced with the middle leader.
-     */
-    for (p = lead_flags; *p && *p != ':'; ++p) {
-      if (*p == COM_BLANK) {
-        require_blank = TRUE;
-        continue;
-      }
-      if (*p == COM_START || *p == COM_MIDDLE) {
-        current_flag = *p;
-        if (*p == COM_START) {
-          /*
-           * Doing "O" on a start of comment does not insert leader.
-           */
-          if (dir == BACKWARD) {
-            lead_len = 0;
-            break;
-          }
-
-          /* find start of middle part */
-          (void)copy_option_part(&p, lead_middle, COM_MAX_LEN, ",");
-          require_blank = FALSE;
-        }
-
-        /*
-         * Isolate the strings of the middle and end leader.
-         */
-        while (*p && p[-1] != ':') {            /* find end of middle flags */
-          if (*p == COM_BLANK)
-            require_blank = TRUE;
-          ++p;
-        }
-        (void)copy_option_part(&p, lead_middle, COM_MAX_LEN, ",");
-
-        while (*p && p[-1] != ':') {            /* find end of end flags */
-          /* Check whether we allow automatic ending of comments */
-          if (*p == COM_AUTO_END)
-            end_comment_pending = -1;             /* means we want to set it */
-          ++p;
-        }
-        size_t n = copy_option_part(&p, lead_end, COM_MAX_LEN, ",");
-
-        if (end_comment_pending == -1)          /* we can set it now */
-          end_comment_pending = lead_end[n - 1];
-
-        /*
-         * If the end of the comment is in the same line, don't use
-         * the comment leader.
-         */
-        if (dir == FORWARD) {
-          for (p = saved_line + lead_len; *p; ++p)
-            if (STRNCMP(p, lead_end, n) == 0) {
-              comment_end = p;
-              lead_len = 0;
-              break;
-            }
-        }
-
-        /*
-         * Doing "o" on a start of comment inserts the middle leader.
-         */
-        if (lead_len > 0) {
-          if (current_flag == COM_START) {
-            lead_repl = lead_middle;
-            lead_repl_len = (int)STRLEN(lead_middle);
-          }
-
-          /*
-           * If we have hit RETURN immediately after the start
-           * comment leader, then put a space after the middle
-           * comment leader on the next line.
-           */
-          if (!ascii_iswhite(saved_line[lead_len - 1])
-              && ((p_extra != NULL
-                   && (int)curwin->w_cursor.col == lead_len)
-                  || (p_extra == NULL
-                      && saved_line[lead_len] == NUL)
-                  || require_blank))
-            extra_space = TRUE;
-        }
-        break;
-      }
-      if (*p == COM_END) {
-        /*
-         * Doing "o" on the end of a comment does not insert leader.
-         * Remember where the end is, might want to use it to find the
-         * start (for C-comments).
-         */
-        if (dir == FORWARD) {
-          comment_end = skipwhite(saved_line);
-          lead_len = 0;
-          break;
-        }
-
-        /*
-         * Doing "O" on the end of a comment inserts the middle leader.
-         * Find the string for the middle leader, searching backwards.
-         */
-        while (p > curbuf->b_p_com && *p != ',')
-          --p;
-        for (lead_repl = p; lead_repl > curbuf->b_p_com
-             && lead_repl[-1] != ':'; --lead_repl)
-          ;
-        lead_repl_len = (int)(p - lead_repl);
-
-        /* We can probably always add an extra space when doing "O" on
-         * the comment-end */
-        extra_space = TRUE;
-
-        /* Check whether we allow automatic ending of comments */
-        for (p2 = p; *p2 && *p2 != ':'; p2++) {
-          if (*p2 == COM_AUTO_END)
-            end_comment_pending = -1;             /* means we want to set it */
-        }
-        if (end_comment_pending == -1) {
-          /* Find last character in end-comment string */
-          while (*p2 && *p2 != ',')
-            p2++;
-          end_comment_pending = p2[-1];
-        }
-        break;
-      }
-      if (*p == COM_FIRST) {
-        /*
-         * Comment leader for first line only:	Don't repeat leader
-         * when using "O", blank out leader when using "o".
-         */
-        if (dir == BACKWARD)
-          lead_len = 0;
-        else {
-          lead_repl = (char_u *)"";
-          lead_repl_len = 0;
-        }
-        break;
-      }
-    }
-    if (lead_len > 0) {
-      // allocate buffer (may concatenate p_extra later)
-      int bytes = lead_len
-          + lead_repl_len
-          + extra_space
-          + extra_len
-          + (second_line_indent > 0 ? second_line_indent : 0)
-          + 1;
-      assert(bytes >= 0);
-      leader = xmalloc((size_t)bytes);
-      allocated = leader;  // remember to free it later
-
-      STRLCPY(leader, saved_line, lead_len + 1);
-
-      /*
-       * Replace leader with lead_repl, right or left adjusted
-       */
-      if (lead_repl != NULL) {
-        int c = 0;
-        int off = 0;
-
-        for (p = lead_flags; *p != NUL && *p != ':'; ) {
-          if (*p == COM_RIGHT || *p == COM_LEFT)
-            c = *p++;
-          else if (ascii_isdigit(*p) || *p == '-')
-            off = getdigits_int(&p);
-          else
-            ++p;
-        }
-        if (c == COM_RIGHT) {            /* right adjusted leader */
-          /* find last non-white in the leader to line up with */
-          for (p = leader + lead_len - 1; p > leader
-               && ascii_iswhite(*p); --p)
-            ;
-          ++p;
-
-          /* Compute the length of the replaced characters in
-           * screen characters, not bytes. */
-          {
-            int repl_size = vim_strnsize(lead_repl,
-                lead_repl_len);
-            int old_size = 0;
-            char_u  *endp = p;
-            int l;
-
-            while (old_size < repl_size && p > leader) {
-              MB_PTR_BACK(leader, p);
-              old_size += ptr2cells(p);
-            }
-            l = lead_repl_len - (int)(endp - p);
-            if (l != 0)
-              memmove(endp + l, endp,
-                  (size_t)((leader + lead_len) - endp));
-            lead_len += l;
-          }
-          memmove(p, lead_repl, (size_t)lead_repl_len);
-          if (p + lead_repl_len > leader + lead_len)
-            p[lead_repl_len] = NUL;
-
-          /* blank-out any other chars from the old leader. */
-          while (--p >= leader) {
-            int l = utf_head_off(leader, p);
-
-            if (l > 1) {
-              p -= l;
-              if (ptr2cells(p) > 1) {
-                p[1] = ' ';
-                --l;
-              }
-              memmove(p + 1, p + l + 1,
-                  (size_t)((leader + lead_len) - (p + l + 1)));
-              lead_len -= l;
-              *p = ' ';
-            } else if (!ascii_iswhite(*p))
-              *p = ' ';
-          }
-        } else {                        /* left adjusted leader */
-          p = skipwhite(leader);
-          /* Compute the length of the replaced characters in
-           * screen characters, not bytes. Move the part that is
-           * not to be overwritten. */
-          {
-            int repl_size = vim_strnsize(lead_repl,
-                lead_repl_len);
-            int i;
-            int l;
-
-            for (i = 0; i < lead_len && p[i] != NUL; i += l) {
-              l = (*mb_ptr2len)(p + i);
-              if (vim_strnsize(p, i + l) > repl_size)
-                break;
-            }
-            if (i != lead_repl_len) {
-              memmove(p + lead_repl_len, p + i,
-                  (size_t)(lead_len - i - (p - leader)));
-              lead_len += lead_repl_len - i;
-            }
-          }
-          memmove(p, lead_repl, (size_t)lead_repl_len);
-
-          /* Replace any remaining non-white chars in the old
-           * leader by spaces.  Keep Tabs, the indent must
-           * remain the same. */
-          for (p += lead_repl_len; p < leader + lead_len; ++p)
-            if (!ascii_iswhite(*p)) {
-              /* Don't put a space before a TAB. */
-              if (p + 1 < leader + lead_len && p[1] == TAB) {
-                lead_len--;
-                memmove(p, p + 1, (size_t)(leader + lead_len - p));
-              } else {
-                int l = (*mb_ptr2len)(p);
-
-                if (l > 1) {
-                  if (ptr2cells(p) > 1) {
-                    /* Replace a double-wide char with
-                     * two spaces */
-                    --l;
-                    *p++ = ' ';
-                  }
-                  memmove(p + 1, p + l, (size_t)(leader + lead_len - p));
-                  lead_len -= l - 1;
-                }
-                *p = ' ';
-              }
-            }
-          *p = NUL;
-        }
-
-        /* Recompute the indent, it may have changed. */
-        if (curbuf->b_p_ai
-            || do_si
-            )
-          newindent = get_indent_str(leader, (int)curbuf->b_p_ts, false);
-
-        /* Add the indent offset */
-        if (newindent + off < 0) {
-          off = -newindent;
-          newindent = 0;
-        } else
-          newindent += off;
-
-        /* Correct trailing spaces for the shift, so that
-         * alignment remains equal. */
-        while (off > 0 && lead_len > 0
-               && leader[lead_len - 1] == ' ') {
-          /* Don't do it when there is a tab before the space */
-          if (vim_strchr(skipwhite(leader), '\t') != NULL)
-            break;
-          --lead_len;
-          --off;
-        }
-
-        /* If the leader ends in white space, don't add an
-         * extra space */
-        if (lead_len > 0 && ascii_iswhite(leader[lead_len - 1]))
-          extra_space = FALSE;
-        leader[lead_len] = NUL;
-      }
-
-      if (extra_space) {
-        leader[lead_len++] = ' ';
-        leader[lead_len] = NUL;
-      }
-
-      newcol = lead_len;
-
-      /*
-       * if a new indent will be set below, remove the indent that
-       * is in the comment leader
-       */
-      if (newindent
-          || did_si
-          ) {
-        while (lead_len && ascii_iswhite(*leader)) {
-          --lead_len;
-          --newcol;
-          ++leader;
-        }
-      }
-
-      did_si = can_si = false;
-    } else if (comment_end != NULL) {
-      // We have finished a comment, so we don't use the leader.
-      // If this was a C-comment and 'ai' or 'si' is set do a normal
-      // indent to align with the line containing the start of the
-      // comment.
-      if (comment_end[0] == '*' && comment_end[1] == '/'
-          && (curbuf->b_p_ai || do_si)) {
-        old_cursor = curwin->w_cursor;
-        curwin->w_cursor.col = (colnr_T)(comment_end - saved_line);
-        if ((pos = findmatch(NULL, NUL)) != NULL) {
-          curwin->w_cursor.lnum = pos->lnum;
-          newindent = get_indent();
-        }
-        curwin->w_cursor = old_cursor;
-      }
-    }
-  }
-
-  /* (State == INSERT || State == REPLACE), only when dir == FORWARD */
-  if (p_extra != NULL) {
-    *p_extra = saved_char;              /* restore char that NUL replaced */
-
-    /*
-     * When 'ai' set or "flags" has OPENLINE_DELSPACES, skip to the first
-     * non-blank.
-     *
-     * When in REPLACE mode, put the deleted blanks on the replace stack,
-     * preceded by a NUL, so they can be put back when a BS is entered.
-     */
-    if (REPLACE_NORMAL(State))
-      replace_push(NUL);            /* end of extra blanks */
-    if (curbuf->b_p_ai || (flags & OPENLINE_DELSPACES)) {
-      while ((*p_extra == ' ' || *p_extra == '\t')
-             && !utf_iscomposing(utf_ptr2char(p_extra + 1))) {
-        if (REPLACE_NORMAL(State)) {
-          replace_push(*p_extra);
-        }
-        p_extra++;
-        less_cols_off++;
-      }
-    }
-
-    /* columns for marks adjusted for removed columns */
-    less_cols = (int)(p_extra - saved_line);
-  }
-
-  if (p_extra == NULL)
-    p_extra = (char_u *)"";                 /* append empty line */
-
-  /* concatenate leader and p_extra, if there is a leader */
-  if (lead_len > 0) {
-    if (flags & OPENLINE_COM_LIST && second_line_indent > 0) {
-      int i;
-      int padding = second_line_indent
-                    - (newindent + (int)STRLEN(leader));
-
-      /* Here whitespace is inserted after the comment char.
-       * Below, set_indent(newindent, SIN_INSERT) will insert the
-       * whitespace needed before the comment char. */
-      for (i = 0; i < padding; i++) {
-        STRCAT(leader, " ");
-        less_cols--;
-        newcol++;
-      }
-    }
-    STRCAT(leader, p_extra);
-    p_extra = leader;
-    did_ai = true;          // So truncating blanks works with comments
-    less_cols -= lead_len;
-  } else
-    end_comment_pending = NUL;      /* turns out there was no leader */
-
-  old_cursor = curwin->w_cursor;
-  if (dir == BACKWARD)
-    --curwin->w_cursor.lnum;
-  if (!(State & VREPLACE_FLAG) || old_cursor.lnum >= orig_line_count) {
-    if (ml_append(curwin->w_cursor.lnum, p_extra, (colnr_T)0, false) == FAIL) {
-      goto theend;
-    }
-    // Postpone calling changed_lines(), because it would mess up folding
-    // with markers.
-    // Skip mark_adjust when adding a line after the last one, there can't
-    // be marks there. But still needed in diff mode.
-    if (curwin->w_cursor.lnum + 1 < curbuf->b_ml.ml_line_count
-        || curwin->w_p_diff) {
-      mark_adjust(curwin->w_cursor.lnum + 1, (linenr_T)MAXLNUM, 1L, 0L, false);
-    }
-    did_append = true;
-  } else {
-    /*
-     * In VREPLACE mode we are starting to replace the next line.
-     */
-    curwin->w_cursor.lnum++;
-    if (curwin->w_cursor.lnum >= Insstart.lnum + vr_lines_changed) {
-      /* In case we NL to a new line, BS to the previous one, and NL
-       * again, we don't want to save the new line for undo twice.
-       */
-      (void)u_save_cursor();                        /* errors are ignored! */
-      vr_lines_changed++;
-    }
-    ml_replace(curwin->w_cursor.lnum, p_extra, true);
-    changed_bytes(curwin->w_cursor.lnum, 0);
-    curwin->w_cursor.lnum--;
-    did_append = FALSE;
-  }
-
-  inhibit_delete_count++;
-  if (newindent
-      || did_si
-      ) {
-    ++curwin->w_cursor.lnum;
-    if (did_si) {
-      int sw = get_sw_value(curbuf);
-
-      if (p_sr)
-        newindent -= newindent % sw;
-      newindent += sw;
-    }
-    /* Copy the indent */
-    if (curbuf->b_p_ci) {
-      (void)copy_indent(newindent, saved_line);
-
-      /*
-       * Set the 'preserveindent' option so that any further screwing
-       * with the line doesn't entirely destroy our efforts to preserve
-       * it.  It gets restored at the function end.
-       */
-      curbuf->b_p_pi = TRUE;
-    } else
-      (void)set_indent(newindent, SIN_INSERT);
-    less_cols -= curwin->w_cursor.col;
-
-    ai_col = curwin->w_cursor.col;
-
-    /*
-     * In REPLACE mode, for each character in the new indent, there must
-     * be a NUL on the replace stack, for when it is deleted with BS
-     */
-    if (REPLACE_NORMAL(State)) {
-      for (colnr_T n = 0; n < curwin->w_cursor.col; n++) {
-        replace_push(NUL);
-      }
-    }
-    newcol += curwin->w_cursor.col;
-    if (no_si) {
-      did_si = false;
-    }
-  }
-  inhibit_delete_count--;
-
-  /*
-   * In REPLACE mode, for each character in the extra leader, there must be
-   * a NUL on the replace stack, for when it is deleted with BS.
-   */
-  if (REPLACE_NORMAL(State))
-    while (lead_len-- > 0)
-      replace_push(NUL);
-
-  curwin->w_cursor = old_cursor;
-
-  if (dir == FORWARD) {
-    if (trunc_line || (State & INSERT)) {
-      // truncate current line at cursor
-      saved_line[curwin->w_cursor.col] = NUL;
-      // Remove trailing white space, unless OPENLINE_KEEPTRAIL used.
-      if (trunc_line && !(flags & OPENLINE_KEEPTRAIL)) {
-        truncate_spaces(saved_line);
-      }
-      ml_replace(curwin->w_cursor.lnum, saved_line, false);
-      saved_line = NULL;
-      if (did_append) {
-        changed_lines(curwin->w_cursor.lnum, curwin->w_cursor.col,
-                      curwin->w_cursor.lnum + 1, 1L, true);
-        did_append = false;
-
-        /* Move marks after the line break to the new line. */
-        if (flags & OPENLINE_MARKFIX)
-          mark_col_adjust(curwin->w_cursor.lnum,
-                          curwin->w_cursor.col + less_cols_off,
-                          1L, (long)-less_cols, 0);
-      } else {
-        changed_bytes(curwin->w_cursor.lnum, curwin->w_cursor.col);
-      }
-    }
-
-    /*
-     * Put the cursor on the new line.  Careful: the scrollup() above may
-     * have moved w_cursor, we must use old_cursor.
-     */
-    curwin->w_cursor.lnum = old_cursor.lnum + 1;
-  }
-  if (did_append) {
-    changed_lines(curwin->w_cursor.lnum, 0, curwin->w_cursor.lnum, 1L, true);
-  }
-
-  curwin->w_cursor.col = newcol;
-  curwin->w_cursor.coladd = 0;
-
-  /*
-   * In VREPLACE mode, we are handling the replace stack ourselves, so stop
-   * fixthisline() from doing it (via change_indent()) by telling it we're in
-   * normal INSERT mode.
-   */
-  if (State & VREPLACE_FLAG) {
-    vreplace_mode = State;      /* So we know to put things right later */
-    State = INSERT;
-  } else
-    vreplace_mode = 0;
-  /*
-   * May do lisp indenting.
-   */
-  if (!p_paste
-      && leader == NULL
-      && curbuf->b_p_lisp
-      && curbuf->b_p_ai) {
-    fixthisline(get_lisp_indent);
-    ai_col = (colnr_T)getwhitecols_curline();
-  }
-  /*
-   * May do indenting after opening a new line.
-   */
-  if (!p_paste
-      && (curbuf->b_p_cin
-          || *curbuf->b_p_inde != NUL
-          )
-      && in_cinkeys(dir == FORWARD
-          ? KEY_OPEN_FORW
-          : KEY_OPEN_BACK, ' ', linewhite(curwin->w_cursor.lnum))) {
-    do_c_expr_indent();
-    ai_col = (colnr_T)getwhitecols_curline();
-  }
-  if (vreplace_mode != 0)
-    State = vreplace_mode;
-
-  /*
-   * Finally, VREPLACE gets the stuff on the new line, then puts back the
-   * original line, and inserts the new stuff char by char, pushing old stuff
-   * onto the replace stack (via ins_char()).
-   */
-  if (State & VREPLACE_FLAG) {
-    /* Put new line in p_extra */
-    p_extra = vim_strsave(get_cursor_line_ptr());
-
-    // Put back original line
-    ml_replace(curwin->w_cursor.lnum, next_line, false);
-
-    /* Insert new stuff into line again */
-    curwin->w_cursor.col = 0;
-    curwin->w_cursor.coladd = 0;
-    ins_bytes(p_extra);         /* will call changed_bytes() */
-    xfree(p_extra);
-    next_line = NULL;
-  }
-
-  retval = true;                // success!
-theend:
-  curbuf->b_p_pi = saved_pi;
-  xfree(saved_line);
-  xfree(next_line);
-  xfree(allocated);
-  return retval;
-}
-
-/*
  * get_leader_len() returns the length in bytes of the prefix of the given
  * string which introduces a comment.  If this string is not a comment then
  * 0 is returned.