Introduce nvim namespace: Move files.

Move files from src/ to src/nvim/.
- src/nvim/ becomes the new root dir for nvim executable sources.
- src/libnvim/ is planned to become root dir of the neovim library.

1 files changed, 0 insertions, 3547 deletions

diff --git a/src/misc1.c b/src/misc1.c
deleted file mode 100644
index 26b649331a..0000000000
--- a/src/misc1.c
+++ /dev/null
@@ -1,3547 +0,0 @@
-/*
- * VIM - Vi IMproved	by Bram Moolenaar
- *
- * Do ":help uganda"  in Vim to read copying and usage conditions.
- * Do ":help credits" in Vim to see a list of people who contributed.
- * See README.txt for an overview of the Vim source code.
- */
-
-/*
- * misc1.c: functions that didn't seem to fit elsewhere
- */
-
-#include <string.h>
-
-#include "vim.h"
-#include "version_defs.h"
-#include "misc1.h"
-#include "charset.h"
-#include "diff.h"
-#include "edit.h"
-#include "eval.h"
-#include "ex_cmds.h"
-#include "ex_docmd.h"
-#include "ex_getln.h"
-#include "fileio.h"
-#include "fold.h"
-#include "getchar.h"
-#include "indent.h"
-#include "indent_c.h"
-#include "main.h"
-#include "mark.h"
-#include "mbyte.h"
-#include "memline.h"
-#include "memory.h"
-#include "message.h"
-#include "misc2.h"
-#include "garray.h"
-#include "move.h"
-#include "option.h"
-#include "os_unix.h"
-#include "path.h"
-#include "quickfix.h"
-#include "regexp.h"
-#include "screen.h"
-#include "search.h"
-#include "tag.h"
-#include "term.h"
-#include "ui.h"
-#include "undo.h"
-#include "window.h"
-#include "os/os.h"
-#include "os/shell.h"
-static char_u *vim_version_dir(char_u *vimdir);
-static char_u *remove_tail(char_u *p, char_u *pend, char_u *name);
-static void init_users(void);
-
-/* All user names (for ~user completion as done by shell). */
-static garray_T ga_users;
-
-/*
- * 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      *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 = FALSE;                   /* return value, default is FAIL */
-  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 */
-#if defined(FEAT_SMARTINDENT) || defined(FEAT_VREPLACE) || defined(FEAT_LISP) \
-  || defined(FEAT_CINDENT) || defined(FEAT_COMMENTS)
-  char_u      *p;
-#endif
-  int saved_char = NUL;                 /* init for GCC */
-  pos_T       *pos;
-  int do_si = (!p_paste && curbuf->b_p_si
-               && !curbuf->b_p_cin
-               );
-  int no_si = FALSE;                    /* reset did_si afterwards */
-  int first_char = NUL;                 /* init for GCC */
-  int vreplace_mode;
-  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;
-  }
-
-  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);
-    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 && 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 (
-          lead_len == 0 &&
-          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;
-
-    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;
-        }
-        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 */
-
-      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)
-              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 = mb_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 (!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; p[i] != NUL && i < lead_len; 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 (!vim_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,
-                    (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,
-                      (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);
-
-        /* 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
-          || did_si
-          ) {
-        while (lead_len && vim_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')
-             && (!enc_utf8
-                 || !utf_iscomposing(utf_ptr2char(p_extra + 1)))
-             ) {
-        if (REPLACE_NORMAL(State))
-          replace_push(*p_extra);
-        ++p_extra;
-        ++less_cols_off;
-      }
-    }
-    if (*p_extra != NUL)
-      did_ai = FALSE;               /* append some text, don't truncate now */
-
-    /* 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) {
-    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. */
-    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 (newindent
-      || did_si
-      ) {
-    ++curwin->w_cursor.lnum;
-    if (did_si) {
-      int sw = (int)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 (n = 0; n < (int)curwin->w_cursor.col; ++n)
-        replace_push(NUL);
-    newcol += curwin->w_cursor.col;
-    if (no_si)
-      did_si = FALSE;
-  }
-
-  /*
-   * 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);
-        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);
-      } 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);
-
-  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);
-    p = ml_get_curline();
-    ai_col = (colnr_T)(skipwhite(p) - p);
-  }
-  /*
-   * 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();
-    p = ml_get_curline();
-    ai_col = (colnr_T)(skipwhite(p) - p);
-  }
-  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(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() */
-    free(p_extra);
-    next_line = NULL;
-  }
-
-  retval = TRUE;                /* success! */
-theend:
-  curbuf->b_p_pi = saved_pi;
-  free(saved_line);
-  free(next_line);
-  free(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.
- * When "flags" is not NULL, it is set to point to the flags of the recognized
- * comment leader.
- * "backward" must be true for the "O" command.
- * If "include_space" is set, include trailing whitespace while calculating the
- * length.
- */
-int get_leader_len(char_u *line, char_u **flags, int backward, int include_space)
-{
-  int i, j;
-  int result;
-  int got_com = FALSE;
-  int found_one;
-  char_u part_buf[COM_MAX_LEN];         /* buffer for one option part */
-  char_u      *string;                  /* pointer to comment string */
-  char_u      *list;
-  int middle_match_len = 0;
-  char_u      *prev_list;
-  char_u      *saved_flags = NULL;
-
-  result = i = 0;
-  while (vim_iswhite(line[i]))      /* leading white space is ignored */
-    ++i;
-
-  /*
-   * Repeat to match several nested comment strings.
-   */
-  while (line[i] != NUL) {
-    /*
-     * scan through the 'comments' option for a match
-     */
-    found_one = FALSE;
-    for (list = curbuf->b_p_com; *list; ) {
-      /* Get one option part into part_buf[].  Advance "list" to next
-       * one.  Put "string" at start of string.  */
-      if (!got_com && flags != NULL)
-        *flags = list;              /* remember where flags started */
-      prev_list = list;
-      (void)copy_option_part(&list, part_buf, COM_MAX_LEN, ",");
-      string = vim_strchr(part_buf, ':');
-      if (string == NULL)           /* missing ':', ignore this part */
-        continue;
-      *string++ = NUL;              /* isolate flags from string */
-
-      /* If we found a middle match previously, use that match when this
-       * is not a middle or end. */
-      if (middle_match_len != 0
-          && vim_strchr(part_buf, COM_MIDDLE) == NULL
-          && vim_strchr(part_buf, COM_END) == NULL)
-        break;
-
-      /* When we already found a nested comment, only accept further
-       * nested comments. */
-      if (got_com && vim_strchr(part_buf, COM_NEST) == NULL)
-        continue;
-
-      /* When 'O' flag present and using "O" command skip this one. */
-      if (backward && vim_strchr(part_buf, COM_NOBACK) != NULL)
-        continue;
-
-      /* Line contents and string must match.
-       * When string starts with white space, must have some white space
-       * (but the amount does not need to match, there might be a mix of
-       * TABs and spaces). */
-      if (vim_iswhite(string[0])) {
-        if (i == 0 || !vim_iswhite(line[i - 1]))
-          continue;            /* missing white space */
-        while (vim_iswhite(string[0]))
-          ++string;
-      }<