vim: src/option.c comparison

comparison src/option.c @ 14175:2ad722003b36 v8.1.0105

patch 8.1.0105: all tab stops are the same commit https://github.com/vim/vim/commit/04958cbaf25eea27eceedaa987adfb354ad5f7fd Author: Bram Moolenaar <Bram@vim.org> Date: Sat Jun 23 19:23:02 2018 +0200 patch 8.1.0105: all tab stops are the same Problem: All tab stops are the same. Solution: Add the variable tabstop feature. (Christian Brabandt, closes #2711)

author	Christian Brabandt <cb@256bit.org>
date	Sat, 23 Jun 2018 19:30:07 +0200
parents	1157f16150b3
children	ab64a4fb5edd

comparison

equal deleted inserted replaced

-:d36eedd19166
+:2ad722003b36
 #define PV_TX		OPT_BUF(BV_TX)
 #ifdef FEAT_PERSISTENT_UNDO
 # define PV_UDF		OPT_BUF(BV_UDF)
 #endif
 #define PV_WM		OPT_BUF(BV_WM)
+#ifdef FEAT_VARTABS
+# define PV_VSTS		OPT_BUF(BV_VSTS)
+# define PV_VTS		OPT_BUF(BV_VTS)
+#endif
 /*
 * Definition of the PV_ values for window-local options.
 * The WV_ values are defined in option.h.
 */
 static int	p_tx;
 #ifdef FEAT_PERSISTENT_UNDO
 static int	p_udf;
 #endif
 static long	p_wm;
+#ifdef FEAT_VARTABS
+static char_u	*p_vsts;
+static char_u	*p_vts;
+#endif
 #ifdef FEAT_KEYMAP
 static char_u	*p_keymap;
 #endif
 #ifdef FEAT_TERMINAL
 static long	p_twsl;		/* 'termwinscroll' */
 static int	p_ai_nopaste;
 static int	p_et_nopaste;
 static long	p_sts_nopaste;
 static long	p_tw_nopaste;
 static long	p_wm_nopaste;
+#ifdef FEAT_VARTABS
+static char_u	*p_vsts_nopaste;
+#endif
 struct vimoption
 {
 char	*fullname;	/* full option name */
 char	*shortname;	/* permissible abbreviation */
 			    (char_u *)&p_uc, PV_NONE,
 			    {(char_u *)200L, (char_u *)0L} SCRIPTID_INIT},
 {"updatetime",  "ut",   P_NUM|P_VI_DEF,
 			    (char_u *)&p_ut, PV_NONE,
 			    {(char_u *)4000L, (char_u *)0L} SCRIPTID_INIT},
+{"varsofttabstop", "vsts",  P_STRING|P_VI_DEF|P_VIM|P_COMMA,
+#ifdef FEAT_VARTABS
+			    (char_u *)&p_vsts, PV_VSTS,
+			    {(char_u *)"", (char_u *)0L}
+#else
+			    (char_u *)NULL, PV_NONE,
+			    {(char_u *)"", (char_u *)NULL}
+#endif
+			    SCRIPTID_INIT},
+{"vartabstop",  "vts",  P_STRING|P_VI_DEF|P_VIM|P_RBUF|P_COMMA,
+#ifdef FEAT_VARTABS
+			    (char_u *)&p_vts, PV_VTS,
+			    {(char_u *)"", (char_u *)0L}
+#else
+			    (char_u *)NULL, PV_NONE,
+			    {(char_u *)"", (char_u *)NULL}
+#endif
+			    SCRIPTID_INIT},
 {"verbose",	    "vbs",  P_NUM|P_VI_DEF,
 			    (char_u *)&p_verbose, PV_NONE,
 			    {(char_u *)0L, (char_u *)0L} SCRIPTID_INIT},
 {"verbosefile", "vfile", P_STRING|P_EXPAND|P_VI_DEF|P_SECURE,
 			    (char_u *)&p_vfile, PV_NONE,
 #ifdef FEAT_CLIPBOARD
 /* Parse default for 'clipboard' */
 (void)check_clipboard_option();
 #endif
+#ifdef FEAT_VARTABS
+tabstop_set(curbuf->b_p_vsts, &curbuf->b_p_vsts_array);
+tabstop_set(curbuf->b_p_vts,  &curbuf->b_p_vts_array);
+#endif
 }
 /*
 * Check for string options that are NULL (normally only termcap options).
 */
 check_string_option(&buf->b_p_lw);
 #endif
 check_string_option(&buf->b_p_bkc);
 #ifdef FEAT_MBYTE
 check_string_option(&buf->b_p_menc);
+#endif
+#ifdef FEAT_VARTABS
+check_string_option(&buf->b_p_vsts);
+check_string_option(&buf->b_p_vts);
 #endif
 }
 /*
 * Free the string allocated for an option.
 		errmsg = e_invarg;
 	}
 }
 #endif
+#ifdef FEAT_VARTABS
+/* 'varsofttabstop' */
+else if (varp == &(curbuf->b_p_vsts))
+{
+	char_u *cp;
+	if (!(*varp)[0] || ((*varp)[0] == '0' && !(*varp)[1]))
+	{
+	    if (curbuf->b_p_vsts_array)
+	    {
+		vim_free(curbuf->b_p_vsts_array);
+		curbuf->b_p_vsts_array = 0;
+	    }
+	}
+	else
+	{
+	    for (cp = *varp; *cp; ++cp)
+	    {
+		if (vim_isdigit(*cp))
+		    continue;
+		if (*cp == ',' && cp > *varp && *(cp-1) != ',')
+		    continue;
+		errmsg = e_invarg;
+		break;
+	    }
+	    if (errmsg == NULL)
+	    {
+		int *oldarray = curbuf->b_p_vsts_array;
+		if (tabstop_set(*varp, &(curbuf->b_p_vsts_array)))
+		{
+		    if (oldarray)
+			vim_free(oldarray);
+		}
+		else
+		    errmsg = e_invarg;
+	    }
+	}
+}
+/* 'vartabstop' */
+else if (varp == &(curbuf->b_p_vts))
+{
+	char_u *cp;
+	if (!(*varp)[0] || ((*varp)[0] == '0' && !(*varp)[1]))
+	{
+	    if (curbuf->b_p_vts_array)
+	    {
+		vim_free(curbuf->b_p_vts_array);
+		curbuf->b_p_vts_array = NULL;
+	    }
+	}
+	else
+	{
+	    for (cp = *varp; *cp; ++cp)
+	    {
+		if (vim_isdigit(*cp))
+		    continue;
+		if (*cp == ',' && cp > *varp && *(cp-1) != ',')
+		    continue;
+		errmsg = e_invarg;
+		break;
+	    }
+	    if (errmsg == NULL)
+	    {
+		int *oldarray = curbuf->b_p_vts_array;
+		if (tabstop_set(*varp, &(curbuf->b_p_vts_array)))
+		{
+		    if (oldarray)
+			vim_free(oldarray);
+#ifdef FEAT_FOLDING
+		    if (foldmethodIsIndent(curwin))
+			foldUpdateAll(curwin);
+#endif /* FEAT_FOLDING */
+		}
+		else
+		    errmsg = e_invarg;
+	    }
+	}
+}
+#endif
 /* Options that are a list of flags. */
 else
 {
 	p = NULL;
 	if (varp == &p_ww) /* 'whichwrap' */
 #endif
 if (curbuf->b_p_sw < 0)
 {
 	errmsg = e_positive;
+#ifdef FEAT_VARTABS
+	// Use the first 'vartabstop' value, or 'tabstop' if vts isn't in use.
+	curbuf->b_p_sw = tabstop_count(curbuf->b_p_vts_array) > 0
+	               ? tabstop_first(curbuf->b_p_vts_array)
+		       : curbuf->b_p_ts;
+#else
 	curbuf->b_p_sw = curbuf->b_p_ts;
+#endif
 }
 /*
 * Number options that need some action when changed
 */
 	case PV_KMAP:	return (char_u *)&(curbuf->b_p_keymap);
 #endif
 #ifdef FEAT_SIGNS
 	case PV_SCL:	return (char_u *)&(curwin->w_p_scl);
 #endif
+#ifdef FEAT_VARTABS
+	case PV_VSTS:	return (char_u *)&(curbuf->b_p_vsts);
+	case PV_VTS:	return (char_u *)&(curbuf->b_p_vts);
+#endif
 	default:	IEMSG(_("E356: get_varp ERROR"));
 }
 /* always return a valid pointer to avoid a crash! */
 return (char_u *)&(curbuf->b_p_wm);
 }
 	    buf->b_p_cfu = vim_strsave(p_cfu);
 	    buf->b_p_ofu = vim_strsave(p_ofu);
 #endif
 	    buf->b_p_sts = p_sts;
 	    buf->b_p_sts_nopaste = p_sts_nopaste;
+#ifdef FEAT_VARTABS
+	    buf->b_p_vsts = vim_strsave(p_vsts);
+	    if (p_vsts && p_vsts != empty_option)
+		tabstop_set(p_vsts, &buf->b_p_vsts_array);
+	    else
+		buf->b_p_vsts_array = 0;
+	    buf->b_p_vsts_nopaste = p_vsts_nopaste
+				 ? vim_strsave(p_vsts_nopaste) : NULL;
+#endif
 	    buf->b_p_sn = p_sn;
 #ifdef FEAT_COMMENTS
 	    buf->b_p_com = vim_strsave(p_com);
 #endif
 #ifdef FEAT_FOLDING
 	     * when going from a help buffer to a non-help buffer.
 	     * Don't touch these at all when BCO_NOHELP is used and going from
 	     * or to a help buffer.
 	     */
 	    if (dont_do_help)
+	    {
 		buf->b_p_isk = save_p_isk;
+#ifdef FEAT_VARTABS
+		if (p_vts && p_vts != empty_option && !buf->b_p_vts_array)
+		    tabstop_set(p_vts, &buf->b_p_vts_array);
+		else
+		    buf->b_p_vts_array = NULL;
+#endif
+	    }
 	    else
 	    {
 		buf->b_p_isk = vim_strsave(p_isk);
 		did_isk = TRUE;
 		buf->b_p_ts = p_ts;
+#ifdef FEAT_VARTABS
+		buf->b_p_vts = vim_strsave(p_vts);
+		if (p_vts && p_vts != empty_option && !buf->b_p_vts_array)
+		    tabstop_set(p_vts, &buf->b_p_vts_array);
+		else
+		    buf->b_p_vts_array = NULL;
+#endif
 		buf->b_help = FALSE;
 		if (buf->b_p_bt[0] == 'h')
 		    clear_string_option(&buf->b_p_bt);
 		buf->b_p_ma = p_ma;
 	    }
 		buf->b_p_tw_nopaste = buf->b_p_tw;
 		buf->b_p_wm_nopaste = buf->b_p_wm;
 		buf->b_p_sts_nopaste = buf->b_p_sts;
 		buf->b_p_ai_nopaste = buf->b_p_ai;
 		buf->b_p_et_nopaste = buf->b_p_et;
+#ifdef FEAT_VARTABS
+		if (buf->b_p_vsts_nopaste)
+		    vim_free(buf->b_p_vsts_nopaste);
+		buf->b_p_vsts_nopaste = buf->b_p_vsts && buf->b_p_vsts != empty_option
+				     ? vim_strsave(buf->b_p_vsts) : NULL;
+#endif
 	    }
 	    /* save global options */
 	    save_sm = p_sm;
 	    save_sta = p_sta;
 	    p_ai_nopaste = p_ai;
 	    p_et_nopaste = p_et;
 	    p_sts_nopaste = p_sts;
 	    p_tw_nopaste = p_tw;
 	    p_wm_nopaste = p_wm;
+#ifdef FEAT_VARTABS
+	    if (p_vsts_nopaste)
+		vim_free(p_vsts_nopaste);
+	    p_vsts_nopaste = p_vsts && p_vsts != empty_option ? vim_strsave(p_vsts) : NULL;
+#endif
 	}
 	/*
 	 * Always set the option values, also when 'paste' is set when it is
 	 * already on.
 	    buf->b_p_tw = 0;	    /* textwidth is 0 */
 	    buf->b_p_wm = 0;	    /* wrapmargin is 0 */
 	    buf->b_p_sts = 0;	    /* softtabstop is 0 */
 	    buf->b_p_ai = 0;	    /* no auto-indent */
 	    buf->b_p_et = 0;	    /* no expandtab */
+#ifdef FEAT_VARTABS
+	    if (buf->b_p_vsts)
+		free_string_option(buf->b_p_vsts);
+	    buf->b_p_vsts = empty_option;
+	    if (buf->b_p_vsts_array)
+		vim_free(buf->b_p_vsts_array);
+	    buf->b_p_vsts_array = 0;
+#endif
 	}
 	/* set global options */
 	p_sm = 0;		    /* no showmatch */
 	p_sta = 0;		    /* no smarttab */
 	/* set global values for local buffer options */
 	p_tw = 0;
 	p_wm = 0;
 	p_sts = 0;
 	p_ai = 0;
+#ifdef FEAT_VARTABS
+	if (p_vsts)
+	    free_string_option(p_vsts);
+	p_vsts = empty_option;
+#endif
 }
 /*
 * Paste switched from on to off: Restore saved values.
 */
 	    buf->b_p_tw = buf->b_p_tw_nopaste;
 	    buf->b_p_wm = buf->b_p_wm_nopaste;
 	    buf->b_p_sts = buf->b_p_sts_nopaste;
 	    buf->b_p_ai = buf->b_p_ai_nopaste;
 	    buf->b_p_et = buf->b_p_et_nopaste;
+#ifdef FEAT_VARTABS
+	    if (buf->b_p_vsts)
+		free_string_option(buf->b_p_vsts);
+	    buf->b_p_vsts = buf->b_p_vsts_nopaste
+			 ? vim_strsave(buf->b_p_vsts_nopaste) : empty_option;
+	    if (buf->b_p_vsts_array)
+		vim_free(buf->b_p_vsts_array);
+	    if (buf->b_p_vsts && buf->b_p_vsts != empty_option)
+		tabstop_set(buf->b_p_vsts, &buf->b_p_vsts_array);
+	    else
+		buf->b_p_vsts_array = 0;
+#endif
 	}
 	/* restore global options */
 	p_sm = save_sm;
 	p_sta = save_sta;
 	p_ai = p_ai_nopaste;
 	p_et = p_et_nopaste;
 	p_sts = p_sts_nopaste;
 	p_tw = p_tw_nopaste;
 	p_wm = p_wm_nopaste;
+#ifdef FEAT_VARTABS
+	if (p_vsts)
+	    free_string_option(p_vsts);
+	p_vsts = p_vsts_nopaste ? vim_strsave(p_vsts_nopaste) : empty_option;
+#endif
 }
 old_p_paste = p_paste;
 }
 int
 check_ff_value(char_u *p)
 {
 return check_opt_strings(p, p_ff_values, FALSE);
 }
+#ifdef FEAT_VARTABS
+/*
+* Set the integer values corresponding to the string setting of 'vartabstop'.
+*/
+int
+tabstop_set(char_u *var, int **array)
+{
+int valcount = 1;
+int t;
+char_u *cp;
+if ((!var[0] || (var[0] == '0' && !var[1])))
+{
+	*array = NULL;
+	return TRUE;
+}
+for (cp = var; *cp; ++cp)
+{
+	if (cp == var || *(cp - 1) == ',')
+	{
+	    char_u *end;
+	    if (strtol((char *)cp, (char **)&end, 10) <= 0)
+	    {
+		if (cp != end)
+		    EMSG(_(e_positive));
+		else
+		    EMSG(_(e_invarg));
+		return FALSE;
+	    }
+	}
+	if (VIM_ISDIGIT(*cp))
+	    continue;
+	if (*cp == ',' && cp > var && *(cp - 1) != ',')
+	{
+	    ++valcount;
+	    continue;
+	}
+	EMSG(_(e_invarg));
+	return FALSE;
+}
+*array = (int *) alloc((unsigned) ((valcount + 1) * sizeof(int)));
+(*array)[0] = valcount;
+t = 1;
+for (cp = var; *cp;)
+{
+	(*array)[t++] = atoi((char *)cp);
+	while (*cp && *cp != ',')
+	    ++cp;
+	if (*cp)
+	    ++cp;
+}
+return TRUE;
+}
+/*
+* Calculate the number of screen spaces a tab will occupy.
+* If "vts" is set then the tab widths are taken from that array,
+* otherwise the value of ts is used.
+*/
+int
+tabstop_padding(colnr_T col, int ts_arg, int *vts)
+{
+int		ts = ts_arg == 0 ? 8 : ts_arg;
+int		tabcount;
+colnr_T	tabcol = 0;
+int		t;
+int		padding = 0;
+if (vts == NULL || vts[0] == 0)
+	return ts - (col % ts);
+tabcount = vts[0];
+for (t = 1; t <= tabcount; ++t)
+{
+	tabcol += vts[t];
+	if (tabcol > col)
+	{
+	    padding = (int)(tabcol - col);
+	    break;
+	}
+}
+if (t > tabcount)
+	padding = vts[tabcount] - (int)((col - tabcol) % vts[tabcount]);
+return padding;
+}
+/*
+* Find the size of the tab that covers a particular column.
+*/
+int
+tabstop_at(colnr_T col, int ts, int *vts)
+{
+int		tabcount;
+colnr_T	tabcol = 0;
+int		t;
+int		tab_size = 0;
+if (vts == 0 || vts[0] == 0)
+	return ts;
+tabcount = vts[0];
+for (t = 1; t <= tabcount; ++t)
+{
+	tabcol += vts[t];
+	if (tabcol > col)
+	{
+	    tab_size = vts[t];
+	    break;
+	}
+}
+if (t > tabcount)
+	tab_size = vts[tabcount];
+return tab_size;
+}
+/*
+* Find the column on which a tab starts.
+*/
+colnr_T
+tabstop_start(colnr_T col, int ts, int *vts)
+{
+int		tabcount;
+colnr_T	tabcol = 0;
+int		t;
+int         excess;
+if (vts == 0 || vts[0] == 0)
+	return (col / ts) * ts;
+tabcount = vts[0];
+for (t = 1; t <= tabcount; ++t)
+{
+	tabcol += vts[t];
+	if (tabcol > col)
+	    return tabcol - vts[t];
+}
+excess = tabcol % vts[tabcount];
+return excess + ((col - excess) / vts[tabcount]) * vts[tabcount];
+}
+/*
+* Find the number of tabs and spaces necessary to get from one column
+* to another.
+*/
+void
+tabstop_fromto(
+	colnr_T start_col,
+	colnr_T end_col,
+	int	ts,
+	int	*vts,
+	int	*ntabs,
+	int	*nspcs)
+{
+int		spaces = end_col - start_col;
+colnr_T	tabcol = 0;
+int		padding = 0;
+int		tabcount;
+int		t;
+if (vts == 0 || vts[0] == 0)
+{
+	int tabs = 0;
+	int initspc = ts - (start_col % ts);
+	if (spaces >= initspc)
+	{
+	    spaces -= initspc;
+	    tabs++;
+	}
+	tabs += spaces / ts;
+	spaces -= (spaces / ts) * ts;
+	*ntabs = tabs;
+	*nspcs = spaces;
+	return;
+}
+/* Find the padding needed to reach the next tabstop. */
+tabcount = vts[0];
+for (t = 1; t <= tabcount; ++t)
+{
+	tabcol += vts[t];
+	if (tabcol > start_col)
+	{
+	    padding = (int)(tabcol - start_col);
+	    break;
+	}
+}
+if (t > tabcount)
+	padding = vts[tabcount] - (int)((start_col - tabcol) % vts[tabcount]);
+/* If the space needed is less than the padding no tabs can be used. */
+if (spaces < padding)
+{
+	*ntabs = 0;
+	*nspcs = spaces;
+	return;
+}
+*ntabs = 1;
+spaces -= padding;
+/* At least one tab has been used. See if any more will fit. */
+while (spaces != 0 && ++t <= tabcount)
+{
+	padding = vts[t];
+	if (spaces < padding)
+	{
+	    *nspcs = spaces;
+	    return;
+	}
+	++*ntabs;
+	spaces -= padding;
+}
+*ntabs += spaces / vts[tabcount];
+*nspcs =  spaces % vts[tabcount];
+}
+/*
+* See if two tabstop arrays contain the same values.
+*/
+int
+tabstop_eq(int *ts1, int *ts2)
+{
+int		t;
+if ((ts1 == 0 && ts2) || (ts1 && ts2 == 0))
+	return FALSE;
+if (ts1 == ts2)
+	return TRUE;
+if (ts1[0] != ts2[0])
+	return FALSE;
+for (t = 1; t <= ts1[0]; ++t)
+	if (ts1[t] != ts2[t])
+	    return FALSE;
+return TRUE;
+}
+/*
+* Copy a tabstop array, allocating space for the new array.
+*/
+int *
+tabstop_copy(int *oldts)
+{
+int		*newts;
+int		t;
+if (oldts == 0)
+	return 0;
+newts = (int *) alloc((unsigned) ((oldts[0] + 1) * sizeof(int)));
+for (t = 0; t <= oldts[0]; ++t)
+	newts[t] = oldts[t];
+return newts;
+}
+/*
+* Return a count of the number of tabstops.
+*/
+int
+tabstop_count(int *ts)
+{
+return ts != NULL ? ts[0] : 0;
+}
+/*
+* Return the first tabstop, or 8 if there are no tabstops defined.
+*/
+int
+tabstop_first(int *ts)
+{
+return ts != NULL ? ts[1] : 8;
+}
+#endif
 /*
 * Return the effective shiftwidth value for current buffer, using the
 * 'tabstop' value when 'shiftwidth' is zero.
 */

Mercurial > vim

comparison src/option.c @ 14175:2ad722003b36 v8.1.0105