Merge remote-tracking branch 'vim/master'

Author: splhack

runtime/defaults.vim

@@ -1,7 +1,7 @@
 " The default vimrc file.
 "
 " Maintainer:	Bram Moolenaar <[email protected]>
-" Last change:	2016 Sep 02
+" Last change:	2017 Mar 08
 "
 " This is loaded if no vimrc file was found.
 " Except when Vim is run with "-u NONE" or "-C".
@@ -21,7 +21,10 @@ endif
 
 " Use Vim settings, rather than Vi settings (much better!).
 " This must be first, because it changes other options as a side effect.
-set nocompatible
+" Avoid side effects when it was already reset.
+if &compatible
+  set nocompatible
+endif
 
 " Allow backspacing over everything in insert mode.
 set backspace=indent,eol,start

src/auto/configure

@@ -10225,15 +10225,25 @@ fi
 
 
 
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for /proc/self/exe" >&5
-$as_echo_n "checking for /proc/self/exe... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for /proc link to executable" >&5
+$as_echo_n "checking for /proc link to executable... " >&6; }
 if test -L "/proc/self/exe"; then
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
-    $as_echo "#define HAVE_PROC_SELF_EXE 1" >>confdefs.h
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: /proc/self/exe" >&5
+$as_echo "/proc/self/exe" >&6; }
+  $as_echo "#define PROC_EXE_LINK \"/proc/self/exe\"" >>confdefs.h
+
+elif test -L "/proc/self/path/a.out"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: /proc/self/path/a.out" >&5
+$as_echo "/proc/self/path/a.out" >&6; }
+  $as_echo "#define PROC_EXE_LINK \"/proc/self/path/a.out\"" >>confdefs.h
+
+elif test -L "/proc/curproc/file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: /proc/curproc/file" >&5
+$as_echo "/proc/curproc/file" >&6; }
+  $as_echo "#define PROC_EXE_LINK \"/proc/curproc/file\"" >>confdefs.h
 
 else
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 fi
 

src/config.h.in

@@ -446,8 +446,8 @@
 /* Define if fcntl()'s F_SETFD command knows about FD_CLOEXEC */
 #undef HAVE_FD_CLOEXEC
 
-/* Define if /proc/self/exe can be read */
-#undef HAVE_PROC_SELF_EXE
+/* Define if /proc/self/exe or similar can be read */
+#undef PROC_EXE_LINK
 
 /* Define if you want Cygwin to use the WIN32 clipboard, not compatible with X11*/
 #undef FEAT_CYGWIN_WIN32_CLIPBOARD

src/configure.ac

@@ -3105,12 +3105,21 @@ dnl ---------------------------------------------------------------------------
 dnl end of GUI-checking
 dnl ---------------------------------------------------------------------------
 
-AC_MSG_CHECKING([for /proc/self/exe])
+AC_MSG_CHECKING([for /proc link to executable])
 if test -L "/proc/self/exe"; then
-    AC_MSG_RESULT(yes)
-    AC_DEFINE(HAVE_PROC_SELF_EXE)
+  dnl Linux
+  AC_MSG_RESULT([/proc/self/exe])
+  AC_DEFINE(PROC_EXE_LINK, "/proc/self/exe")
+elif test -L "/proc/self/path/a.out"; then
+  dnl Solaris
+  AC_MSG_RESULT([/proc/self/path/a.out])
+  AC_DEFINE(PROC_EXE_LINK, "/proc/self/path/a.out")
+elif test -L "/proc/curproc/file"; then
+  dnl FreeBSD
+  AC_MSG_RESULT([/proc/curproc/file])
+  AC_DEFINE(PROC_EXE_LINK, "/proc/curproc/file")
 else
-    AC_MSG_RESULT(no)
+  AC_MSG_RESULT(no)
 fi
 
 dnl Check for Cygwin, which needs an extra source file if not using X11

src/dict.c

@@ -356,12 +356,12 @@ dict_add_list(dict_T *d, char *key, list_T *list)
     item->di_tv.v_lock = 0;
     item->di_tv.v_type = VAR_LIST;
     item->di_tv.vval.v_list = list;
+    ++list->lv_refcount;
     if (dict_add(d, item) == FAIL)
     {
 	dictitem_free(item);
 	return FAIL;
     }
-    ++list->lv_refcount;
     return OK;
 }
 
@@ -380,12 +380,12 @@ dict_add_dict(dict_T *d, char *key, dict_T *dict)
     item->di_tv.v_lock = 0;
     item->di_tv.v_type = VAR_DICT;
     item->di_tv.vval.v_dict = dict;
+    ++dict->dv_refcount;
     if (dict_add(d, item) == FAIL)
     {
 	dictitem_free(item);
 	return FAIL;
     }
-    ++dict->dv_refcount;
     return OK;
 }
 

src/ex_cmds.c

@@ -799,14 +799,8 @@ do_move(linenr_T line1, linenr_T line2, linenr_T dest)
     linenr_T	num_lines;  /* Num lines moved */
     linenr_T	last_line;  /* Last line in file after adding new text */
 #ifdef FEAT_FOLDING
-    int		isFolded;
-
-    /* Moving lines seems to corrupt the folds, delete folding info now
-     * and recreate it when finished.  Don't do this for manual folding, it
-     * would delete all folds. */
-    isFolded = hasAnyFolding(curwin) && !foldmethodIsManual(curwin);
-    if (isFolded)
-	deleteFoldRecurse(&curwin->w_folds);
+    win_T	*win;
+    tabpage_T	*tp;
 #endif
 
     if (dest >= line1 && dest < line2)
@@ -851,24 +845,34 @@ do_move(linenr_T line1, linenr_T line2, linenr_T dest)
      * their final destination at the new text position -- webb
      */
     last_line = curbuf->b_ml.ml_line_count;
-    mark_adjust(line1, line2, last_line - line2, 0L);
-    changed_lines(last_line - num_lines + 1, 0, last_line + 1, num_lines);
+    mark_adjust_nofold(line1, line2, last_line - line2, 0L);
     if (dest >= line2)
     {
-	mark_adjust(line2 + 1, dest, -num_lines, 0L);
+	mark_adjust_nofold(line2 + 1, dest, -num_lines, 0L);
+#ifdef FEAT_FOLDING
+	FOR_ALL_TAB_WINDOWS(tp, win) {
+	    if (win->w_buffer == curbuf)
+		foldMoveRange(&win->w_folds, line1, line2, dest);
+	}
+#endif
 	curbuf->b_op_start.lnum = dest - num_lines + 1;
 	curbuf->b_op_end.lnum = dest;
     }
     else
     {
-	mark_adjust(dest + 1, line1 - 1, num_lines, 0L);
+	mark_adjust_nofold(dest + 1, line1 - 1, num_lines, 0L);
+#ifdef FEAT_FOLDING
+	FOR_ALL_TAB_WINDOWS(tp, win) {
+	    if (win->w_buffer == curbuf)
+		foldMoveRange(&win->w_folds, dest + 1, line1 - 1, line2);
+	}
+#endif
 	curbuf->b_op_start.lnum = dest + 1;
 	curbuf->b_op_end.lnum = dest + num_lines;
     }
     curbuf->b_op_start.col = curbuf->b_op_end.col = 0;
-    mark_adjust(last_line - num_lines + 1, last_line,
+    mark_adjust_nofold(last_line - num_lines + 1, last_line,
 					     -(last_line - dest - extra), 0L);
-    changed_lines(last_line - num_lines + 1, 0, last_line + 1, -extra);
 
     /*
      * Now we delete the original text -- webb
@@ -906,12 +910,6 @@ do_move(linenr_T line1, linenr_T line2, linenr_T dest)
     else
 	changed_lines(dest + 1, 0, line1 + num_lines, 0L);
 
-#ifdef FEAT_FOLDING
-	/* recreate folds */
-	if (isFolded)
-	    foldUpdateAll(curwin);
-#endif
-
     return OK;
 }
 

src/fold.c

@@ -2968,6 +2968,182 @@ foldRemove(garray_T *gap, linenr_T top, linenr_T bot)
     }
 }
 
+/* foldReverseOrder() {{{2 */
+    static void
+foldReverseOrder(garray_T *gap, linenr_T start, linenr_T end)
+{
+    fold_T *left, *right;
+    fold_T tmp;
+
+    for (; start < end; start++, end--)
+    {
+	left = (fold_T *)gap->ga_data + start;
+	right = (fold_T *)gap->ga_data + end;
+	tmp  = *left;
+	*left = *right;
+	*right = tmp;
+    }
+}
+
+/* foldMoveRange() {{{2 */
+/*
+ * Move folds within the inclusive range "line1" to "line2" to after "dest"
+ * requires "line1" <= "line2" <= "dest"
+ *
+ * There are the following situations for the first fold at or below line1 - 1.
+ *       1  2  3  4
+ *       1  2  3  4
+ * line1    2  3  4
+ *          2  3  4  5  6  7
+ * line2       3  4  5  6  7
+ *             3  4     6  7  8  9
+ * dest           4        7  8  9
+ *                4        7  8    10
+ *                4        7  8    10
+ *
+ * In the following descriptions, "moved" means moving in the buffer, *and* in
+ * the fold array.
+ * Meanwhile, "shifted" just means moving in the buffer.
+ * 1. not changed
+ * 2. truncated above line1
+ * 3. length reduced by  line2 - line1, folds starting between the end of 3 and
+ *    dest are truncated and shifted up
+ * 4. internal folds moved (from [line1, line2] to dest)
+ * 5. moved to dest.
+ * 6. truncated below line2 and moved.
+ * 7. length reduced by line2 - dest, folds starting between line2 and dest are
+ *    removed, top is moved down by move_len.
+ * 8. truncated below dest and shifted up.
+ * 9. shifted up
+ * 10. not changed
+ */
+
+    static void
+truncate_fold(fold_T *fp, linenr_T end)
+{
+    foldRemove(&fp->fd_nested, end - fp->fd_top, MAXLNUM);
+    fp->fd_len = end - fp->fd_top + 1;
+}
+
+#define fold_end(fp) ((fp)->fd_top + (fp)->fd_len - 1)
+#define valid_fold(fp, gap) ((fp) < ((fold_T *)(gap)->ga_data + (gap)->ga_len))
+#define fold_index(fp, gap) ((size_t)(fp - ((fold_T *)(gap)->ga_data)))
+
+    void
+foldMoveRange(garray_T *gap, linenr_T line1, linenr_T line2, linenr_T dest)
+{
+    fold_T *fp;
+    linenr_T range_len = line2 - line1 + 1;
+    linenr_T move_len = dest - line2;
+    int at_start = foldFind(gap, line1 - 1, &fp);
+    size_t move_start = 0, move_end = 0, dest_index = 0;
+
+    if (at_start)
+    {
+	if (fold_end(fp) > dest)
+	{
+	    /* Case 4
+	    * don't have to change this fold, but have to move nested folds.
+	    */
+	    foldMoveRange(&fp->fd_nested, line1 - fp->fd_top, line2 -
+		    fp->fd_top, dest - fp->fd_top);
+	    return;
+	}
+	else if (fold_end(fp) > line2)
+	{
+	    /* Case 3
+	     * Remove nested folds between line1 and line2 & reduce the
+	     * length of fold by "range_len".
+	     * Folds after this one must be dealt with.
+	     */
+	    foldMarkAdjustRecurse(&fp->fd_nested, line1 - fp->fd_top, line2 -
+		    fp->fd_top, MAXLNUM, -range_len);
+	    fp->fd_len -= range_len;
+	}
+	else
+	    /* Case 2 truncate fold, folds after this one must be dealt with. */
+	    truncate_fold(fp, line1);
+
+	/* Look at the next fold, and treat that one as if it were the first
+	 * after  "line1" (because now it is). */
+	fp = fp + 1;
+    }
+
+    if (!valid_fold(fp, gap) || fp->fd_top > dest)
+    {
+	/* Case 10
+	 * No folds after "line1" and before "dest"
+	 */
+	return;
+    }
+    else if (fp->fd_top > line2)
+    {
+	for (; valid_fold(fp, gap) && fold_end(fp) < dest; fp++)
+	/* Case 9. (for all case 9's) -- shift up. */
+	    fp->fd_top -= range_len;
+
+	if (valid_fold(fp, gap) && fp->fd_top < dest)
+	{
+	    /* Case 8. -- ensure truncated at dest, shift up */
+	    truncate_fold(fp, dest);
+	    fp->fd_top -= range_len;
+	}
+	return;
+    }
+    else if (fold_end(fp) > dest)
+    {
+	/* Case 7 -- remove nested folds and shrink */
+	foldMarkAdjustRecurse(&fp->fd_nested, line2 + 1 - fp->fd_top, dest -
+		fp->fd_top, MAXLNUM, -move_len);
+	fp->fd_len -= move_len;
+	fp->fd_top += move_len;
+	return;
+    }
+
+    /* Case 5 or 6
+     * changes rely on whether there are folds between the end of
+     * this fold and "dest".
+     */
+    move_start = fold_index(fp, gap);
+
+    for (; valid_fold(fp, gap) && fp->fd_top <= dest; fp++)
+    {
+	if (fp->fd_top <= line2)
+	{
+	    /* 1. 2. or 3. */
+	    if (fold_end(fp) > line2)
+		/* 2. or 3., truncate before moving */
+		truncate_fold(fp, line2);
+
+	    fp->fd_top += move_len;
+	    continue;
+	}
+
+	/* Record index of the first fold after the moved range. */
+	if (move_end == 0)
+	    move_end = fold_index(fp, gap);
+
+	if (fold_end(fp) > dest)
+	    truncate_fold(fp, dest);
+
+	fp->fd_top -= range_len;
+    }
+
+    dest_index = fold_index(fp, gap);
+
+    /*
+     * All folds are now correct, but they are not necessarily in the correct
+     * order. We have to swap folds in the range [move_end, dest_index) with
+     * those in the range [move_start, move_end).
+     */
+    foldReverseOrder(gap, move_start, dest_index - 1);
+    foldReverseOrder(gap, move_start, move_start + dest_index - move_end - 1);
+    foldReverseOrder(gap, move_start + dest_index - move_end, dest_index - 1);
+}
+#undef fold_end
+#undef valid_fold
+#undef fold_index
+
 /* foldMerge() {{{2 */
 /*
  * Merge two adjacent folds (and the nested ones in them).

src/main.c

@@ -3623,11 +3623,11 @@ set_progpath(char_u *argv0)
 {
     char_u *val = argv0;
 
-# ifdef HAVE_PROC_SELF_EXE
+# ifdef PROC_EXE_LINK
     char    buf[PATH_MAX + 1];
     ssize_t len;
 
-    len = readlink("/proc/self/exe", buf, PATH_MAX);
+    len = readlink(PROC_EXE_LINK, buf, PATH_MAX);
     if (len > 0)
     {
 	buf[len] = NUL;