mirror of
https://github.com/vim/vim
synced 2025-03-15 22:37:52 +01:00
Problem: crash with large id in text_prop interface prop_add()/prop_add_list() (cposture) Solution: Error out if the id is > INT_MAX or <= INT_MIN fixes: #15637 closes: #15638 Signed-off-by: Christian Brabandt <cb@256bit.org>
2492 lines
60 KiB
C
2492 lines
60 KiB
C
/* vi:set ts=8 sts=4 sw=4 noet:
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
/*
|
|
* Text properties implementation. See ":help text-properties".
|
|
*/
|
|
|
|
#include "vim.h"
|
|
|
|
#if defined(FEAT_PROP_POPUP) || defined(PROTO)
|
|
|
|
/*
|
|
* In a hashtable item "hi_key" points to "pt_name" in a proptype_T.
|
|
* This avoids adding a pointer to the hashtable item.
|
|
* PT2HIKEY() converts a proptype pointer to a hashitem key pointer.
|
|
* HIKEY2PT() converts a hashitem key pointer to a proptype pointer.
|
|
* HI2PT() converts a hashitem pointer to a proptype pointer.
|
|
*/
|
|
#define PT2HIKEY(p) ((p)->pt_name)
|
|
#define HIKEY2PT(p) ((proptype_T *)((p) - offsetof(proptype_T, pt_name)))
|
|
#define HI2PT(hi) HIKEY2PT((hi)->hi_key)
|
|
|
|
// The global text property types.
|
|
static hashtab_T *global_proptypes = NULL;
|
|
static proptype_T **global_proparray = NULL;
|
|
|
|
// The last used text property type ID.
|
|
static int proptype_id = 0;
|
|
|
|
/*
|
|
* Find a property type by name, return the hashitem.
|
|
* Returns NULL if the item can't be found.
|
|
*/
|
|
static hashitem_T *
|
|
find_prop_type_hi(char_u *name, buf_T *buf)
|
|
{
|
|
hashtab_T *ht;
|
|
hashitem_T *hi;
|
|
|
|
if (*name == NUL)
|
|
return NULL;
|
|
if (buf == NULL)
|
|
ht = global_proptypes;
|
|
else
|
|
ht = buf->b_proptypes;
|
|
|
|
if (ht == NULL)
|
|
return NULL;
|
|
hi = hash_find(ht, name);
|
|
if (HASHITEM_EMPTY(hi))
|
|
return NULL;
|
|
return hi;
|
|
}
|
|
|
|
/*
|
|
* Like find_prop_type_hi() but return the property type.
|
|
*/
|
|
static proptype_T *
|
|
find_prop_type(char_u *name, buf_T *buf)
|
|
{
|
|
hashitem_T *hi = find_prop_type_hi(name, buf);
|
|
|
|
if (hi == NULL)
|
|
return NULL;
|
|
return HI2PT(hi);
|
|
}
|
|
|
|
/*
|
|
* Get the prop type ID of "name".
|
|
* When not found return zero.
|
|
*/
|
|
int
|
|
find_prop_type_id(char_u *name, buf_T *buf)
|
|
{
|
|
proptype_T *pt = find_prop_type(name, buf);
|
|
|
|
if (pt == NULL)
|
|
return 0;
|
|
return pt->pt_id;
|
|
}
|
|
|
|
/*
|
|
* Lookup a property type by name. First in "buf" and when not found in the
|
|
* global types.
|
|
* When not found gives an error message and returns NULL.
|
|
*/
|
|
static proptype_T *
|
|
lookup_prop_type(char_u *name, buf_T *buf)
|
|
{
|
|
proptype_T *type = find_prop_type(name, buf);
|
|
|
|
if (type == NULL)
|
|
type = find_prop_type(name, NULL);
|
|
if (type == NULL)
|
|
semsg(_(e_property_type_str_does_not_exist), name);
|
|
return type;
|
|
}
|
|
|
|
/*
|
|
* Get an optional "bufnr" item from the dict in "arg".
|
|
* When the argument is not used or "bufnr" is not present then "buf" is
|
|
* unchanged.
|
|
* If "bufnr" is valid or not present return OK.
|
|
* When "arg" is not a dict or "bufnr" is invalid return FAIL.
|
|
*/
|
|
static int
|
|
get_bufnr_from_arg(typval_T *arg, buf_T **buf)
|
|
{
|
|
dictitem_T *di;
|
|
|
|
if (arg->v_type != VAR_DICT)
|
|
{
|
|
emsg(_(e_dictionary_required));
|
|
return FAIL;
|
|
}
|
|
if (arg->vval.v_dict == NULL)
|
|
return OK; // NULL dict is like an empty dict
|
|
di = dict_find(arg->vval.v_dict, (char_u *)"bufnr", -1);
|
|
if (di != NULL && (di->di_tv.v_type != VAR_NUMBER
|
|
|| di->di_tv.vval.v_number != 0))
|
|
{
|
|
*buf = get_buf_arg(&di->di_tv);
|
|
if (*buf == NULL)
|
|
return FAIL;
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* prop_add({lnum}, {col}, {props})
|
|
*/
|
|
void
|
|
f_prop_add(typval_T *argvars, typval_T *rettv)
|
|
{
|
|
linenr_T start_lnum;
|
|
colnr_T start_col;
|
|
|
|
if (in_vim9script()
|
|
&& (check_for_number_arg(argvars, 0) == FAIL
|
|
|| check_for_number_arg(argvars, 1) == FAIL
|
|
|| check_for_dict_arg(argvars, 2) == FAIL))
|
|
return;
|
|
|
|
start_lnum = tv_get_number(&argvars[0]);
|
|
start_col = tv_get_number(&argvars[1]);
|
|
if (check_for_dict_arg(argvars, 2) == FAIL)
|
|
return;
|
|
|
|
rettv->vval.v_number = prop_add_common(start_lnum, start_col,
|
|
argvars[2].vval.v_dict, curbuf, &argvars[2]);
|
|
}
|
|
|
|
/*
|
|
* Attach a text property 'type_name' to the text starting
|
|
* at [start_lnum, start_col] and ending at [end_lnum, end_col] in
|
|
* the buffer "buf" and assign identifier "id".
|
|
* When "text" is not NULL add it to buf->b_textprop_text[-id - 1].
|
|
*/
|
|
static int
|
|
prop_add_one(
|
|
buf_T *buf,
|
|
char_u *type_name,
|
|
int id,
|
|
char_u *text_arg,
|
|
int text_padding_left,
|
|
int text_flags,
|
|
linenr_T start_lnum,
|
|
linenr_T end_lnum,
|
|
colnr_T start_col,
|
|
colnr_T end_col)
|
|
{
|
|
proptype_T *type;
|
|
linenr_T lnum;
|
|
int proplen;
|
|
char_u *props = NULL;
|
|
char_u *newprops;
|
|
size_t textlen;
|
|
char_u *newtext;
|
|
int i;
|
|
textprop_T tmp_prop;
|
|
char_u *text = text_arg;
|
|
int res = FAIL;
|
|
|
|
type = lookup_prop_type(type_name, buf);
|
|
if (type == NULL)
|
|
goto theend;
|
|
|
|
if (start_lnum < 1 || start_lnum > buf->b_ml.ml_line_count)
|
|
{
|
|
semsg(_(e_invalid_line_number_nr), (long)start_lnum);
|
|
goto theend;
|
|
}
|
|
if (end_lnum < start_lnum || end_lnum > buf->b_ml.ml_line_count)
|
|
{
|
|
semsg(_(e_invalid_line_number_nr), (long)end_lnum);
|
|
goto theend;
|
|
}
|
|
|
|
if (buf->b_ml.ml_mfp == NULL)
|
|
{
|
|
emsg(_(e_cannot_add_text_property_to_unloaded_buffer));
|
|
goto theend;
|
|
}
|
|
|
|
if (text != NULL)
|
|
{
|
|
garray_T *gap = &buf->b_textprop_text;
|
|
char_u *p;
|
|
|
|
// double check we got the right ID
|
|
if (-id - 1 != gap->ga_len)
|
|
iemsg("text prop ID mismatch");
|
|
if (gap->ga_growsize == 0)
|
|
ga_init2(gap, sizeof(char *), 50);
|
|
if (ga_grow(gap, 1) == FAIL)
|
|
goto theend;
|
|
((char_u **)gap->ga_data)[gap->ga_len++] = text;
|
|
|
|
// change any control character (Tab, Newline, etc.) to a Space to make
|
|
// it simpler to compute the size
|
|
for (p = text; *p != NUL; MB_PTR_ADV(p))
|
|
if (*p < ' ')
|
|
*p = ' ';
|
|
text = NULL;
|
|
}
|
|
|
|
for (lnum = start_lnum; lnum <= end_lnum; ++lnum)
|
|
{
|
|
colnr_T col; // start column use in tp_col
|
|
colnr_T sort_col; // column where it appears
|
|
long length; // in bytes
|
|
|
|
// Fetch the line to get the ml_line_len field updated.
|
|
proplen = get_text_props(buf, lnum, &props, TRUE);
|
|
textlen = buf->b_ml.ml_line_len - proplen * sizeof(textprop_T);
|
|
|
|
if (lnum == start_lnum)
|
|
col = start_col;
|
|
else
|
|
col = 1;
|
|
if (col - 1 > (colnr_T)textlen && !(col == 0 && text_arg != NULL))
|
|
{
|
|
semsg(_(e_invalid_column_number_nr), (long)start_col);
|
|
goto theend;
|
|
}
|
|
sort_col = col;
|
|
|
|
if (lnum == end_lnum)
|
|
length = end_col - col;
|
|
else
|
|
length = (int)textlen - col + 1;
|
|
if (length > (long)textlen)
|
|
length = (int)textlen; // can include the end-of-line
|
|
if (length < 0)
|
|
length = 0; // zero-width property
|
|
|
|
if (text_arg != NULL)
|
|
{
|
|
length = 1; // text is placed on one character
|
|
if (col == 0)
|
|
{
|
|
col = MAXCOL; // before or after the line
|
|
if ((text_flags & TP_FLAG_ALIGN_ABOVE) == 0)
|
|
sort_col = MAXCOL;
|
|
length += text_padding_left;
|
|
}
|
|
}
|
|
|
|
// Allocate the new line with space for the new property.
|
|
newtext = alloc(buf->b_ml.ml_line_len + sizeof(textprop_T));
|
|
if (newtext == NULL)
|
|
goto theend;
|
|
// Copy the text, including terminating NUL.
|
|
mch_memmove(newtext, buf->b_ml.ml_line_ptr, textlen);
|
|
|
|
// Find the index where to insert the new property.
|
|
// Since the text properties are not aligned properly when stored with
|
|
// the text, we need to copy them as bytes before using it as a struct.
|
|
for (i = 0; i < proplen; ++i)
|
|
{
|
|
colnr_T prop_col;
|
|
|
|
mch_memmove(&tmp_prop, props + i * sizeof(textprop_T),
|
|
sizeof(textprop_T));
|
|
// col is MAXCOL when the text goes above or after the line, when
|
|
// above we should use column zero for sorting
|
|
prop_col = (tmp_prop.tp_flags & TP_FLAG_ALIGN_ABOVE)
|
|
? 0 : tmp_prop.tp_col;
|
|
if (prop_col >= sort_col)
|
|
break;
|
|
}
|
|
newprops = newtext + textlen;
|
|
if (i > 0)
|
|
mch_memmove(newprops, props, sizeof(textprop_T) * i);
|
|
|
|
tmp_prop.tp_col = col;
|
|
tmp_prop.tp_len = length;
|
|
tmp_prop.tp_id = id;
|
|
tmp_prop.tp_type = type->pt_id;
|
|
tmp_prop.tp_flags = text_flags
|
|
| (lnum > start_lnum ? TP_FLAG_CONT_PREV : 0)
|
|
| (lnum < end_lnum ? TP_FLAG_CONT_NEXT : 0)
|
|
| ((type->pt_flags & PT_FLAG_INS_START_INCL)
|
|
? TP_FLAG_START_INCL : 0);
|
|
tmp_prop.tp_padleft = text_padding_left;
|
|
mch_memmove(newprops + i * sizeof(textprop_T), &tmp_prop,
|
|
sizeof(textprop_T));
|
|
|
|
if (i < proplen)
|
|
mch_memmove(newprops + (i + 1) * sizeof(textprop_T),
|
|
props + i * sizeof(textprop_T),
|
|
sizeof(textprop_T) * (proplen - i));
|
|
|
|
if (buf->b_ml.ml_flags & (ML_LINE_DIRTY | ML_ALLOCATED))
|
|
vim_free(buf->b_ml.ml_line_ptr);
|
|
buf->b_ml.ml_line_ptr = newtext;
|
|
buf->b_ml.ml_line_len += sizeof(textprop_T);
|
|
buf->b_ml.ml_flags |= ML_LINE_DIRTY;
|
|
}
|
|
|
|
changed_line_display_buf(buf);
|
|
changed_lines_buf(buf, start_lnum, end_lnum + 1, 0);
|
|
res = OK;
|
|
|
|
theend:
|
|
vim_free(text);
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
* prop_add_list()
|
|
* First argument specifies the text property:
|
|
* {'type': <str>, 'id': <num>, 'bufnr': <num>}
|
|
* Second argument is a List where each item is a List with the following
|
|
* entries: [lnum, start_col, end_col]
|
|
*/
|
|
void
|
|
f_prop_add_list(typval_T *argvars, typval_T *rettv UNUSED)
|
|
{
|
|
dict_T *dict;
|
|
char_u *type_name;
|
|
buf_T *buf = curbuf;
|
|
int id = 0;
|
|
listitem_T *li;
|
|
list_T *pos_list;
|
|
linenr_T start_lnum;
|
|
colnr_T start_col;
|
|
linenr_T end_lnum;
|
|
colnr_T end_col;
|
|
int error = FALSE;
|
|
int prev_did_emsg = did_emsg;
|
|
|
|
if (check_for_dict_arg(argvars, 0) == FAIL
|
|
|| check_for_list_arg(argvars, 1) == FAIL)
|
|
return;
|
|
|
|
if (check_for_nonnull_list_arg(argvars, 1) == FAIL)
|
|
return;
|
|
|
|
dict = argvars[0].vval.v_dict;
|
|
if (dict == NULL || !dict_has_key(dict, "type"))
|
|
{
|
|
emsg(_(e_missing_property_type_name));
|
|
return;
|
|
}
|
|
type_name = dict_get_string(dict, "type", FALSE);
|
|
|
|
if (dict_has_key(dict, "id"))
|
|
{
|
|
vimlong_T x;
|
|
x = dict_get_number(dict, "id");
|
|
if (x > INT_MAX || x <= INT_MIN)
|
|
{
|
|
semsg(_(e_val_too_large), dict_get_string(dict, "id", FALSE));
|
|
return;
|
|
}
|
|
id = (int)x;
|
|
}
|
|
|
|
if (get_bufnr_from_arg(&argvars[0], &buf) == FAIL)
|
|
return;
|
|
|
|
// This must be done _before_ we start adding properties because property
|
|
// changes trigger buffer (memline) reorganisation, which needs this flag
|
|
// to be correctly set.
|
|
buf->b_has_textprop = TRUE; // this is never reset
|
|
FOR_ALL_LIST_ITEMS(argvars[1].vval.v_list, li)
|
|
{
|
|
if (li->li_tv.v_type != VAR_LIST || li->li_tv.vval.v_list == NULL)
|
|
{
|
|
emsg(_(e_list_required));
|
|
return;
|
|
}
|
|
|
|
pos_list = li->li_tv.vval.v_list;
|
|
start_lnum = list_find_nr(pos_list, 0L, &error);
|
|
if (!error)
|
|
start_col = list_find_nr(pos_list, 1L, &error);
|
|
if (!error)
|
|
end_lnum = list_find_nr(pos_list, 2L, &error);
|
|
if (!error)
|
|
end_col = list_find_nr(pos_list, 3L, &error);
|
|
int this_id = id;
|
|
if (!error && pos_list->lv_len > 4)
|
|
this_id = list_find_nr(pos_list, 4L, &error);
|
|
if (error || start_lnum <= 0 || start_col <= 0
|
|
|| end_lnum <= 0 || end_col <= 0)
|
|
{
|
|
if (prev_did_emsg == did_emsg)
|
|
emsg(_(e_invalid_argument));
|
|
return;
|
|
}
|
|
if (prop_add_one(buf, type_name, this_id, NULL, 0, 0,
|
|
start_lnum, end_lnum, start_col, end_col) == FAIL)
|
|
return;
|
|
}
|
|
|
|
redraw_buf_later(buf, UPD_VALID);
|
|
}
|
|
|
|
/*
|
|
* Get the next ID to use for a textprop with text in buffer "buf".
|
|
*/
|
|
static int
|
|
get_textprop_id(buf_T *buf)
|
|
{
|
|
// TODO: recycle deleted entries
|
|
return -(buf->b_textprop_text.ga_len + 1);
|
|
}
|
|
|
|
// Flag that is set when a negative ID isused for a normal text property.
|
|
// It is then impossible to use virtual text properties.
|
|
static int did_use_negative_pop_id = FALSE;
|
|
|
|
/*
|
|
* Shared between prop_add() and popup_create().
|
|
* "dict_arg" is the function argument of a dict containing "bufnr".
|
|
* it is NULL for popup_create().
|
|
* Returns the "id" used for "text" or zero.
|
|
*/
|
|
int
|
|
prop_add_common(
|
|
linenr_T start_lnum,
|
|
colnr_T start_col,
|
|
dict_T *dict,
|
|
buf_T *default_buf,
|
|
typval_T *dict_arg)
|
|
{
|
|
linenr_T end_lnum;
|
|
colnr_T end_col;
|
|
char_u *type_name;
|
|
buf_T *buf = default_buf;
|
|
int id = 0;
|
|
char_u *text = NULL;
|
|
int text_padding_left = 0;
|
|
int flags = 0;
|
|
|
|
if (dict == NULL || !dict_has_key(dict, "type"))
|
|
{
|
|
emsg(_(e_missing_property_type_name));
|
|
goto theend;
|
|
}
|
|
type_name = dict_get_string(dict, "type", FALSE);
|
|
|
|
if (dict_has_key(dict, "end_lnum"))
|
|
{
|
|
end_lnum = dict_get_number(dict, "end_lnum");
|
|
if (end_lnum < start_lnum)
|
|
{
|
|
semsg(_(e_invalid_value_for_argument_str), "end_lnum");
|
|
goto theend;
|
|
}
|
|
}
|
|
else
|
|
end_lnum = start_lnum;
|
|
|
|
if (dict_has_key(dict, "length"))
|
|
{
|
|
long length = dict_get_number(dict, "length");
|
|
|
|
if (length < 0 || end_lnum > start_lnum)
|
|
{
|
|
semsg(_(e_invalid_value_for_argument_str), "length");
|
|
goto theend;
|
|
}
|
|
end_col = start_col + length;
|
|
}
|
|
else if (dict_has_key(dict, "end_col"))
|
|
{
|
|
end_col = dict_get_number(dict, "end_col");
|
|
if (end_col <= 0)
|
|
{
|
|
semsg(_(e_invalid_value_for_argument_str), "end_col");
|
|
goto theend;
|
|
}
|
|
}
|
|
else if (start_lnum == end_lnum)
|
|
end_col = start_col;
|
|
else
|
|
end_col = 1;
|
|
|
|
if (dict_has_key(dict, "id"))
|
|
{
|
|
vimlong_T x;
|
|
x = dict_get_number(dict, "id");
|
|
if (x > INT_MAX || x <= INT_MIN)
|
|
{
|
|
semsg(_(e_val_too_large), dict_get_string(dict, "id", FALSE));
|
|
goto theend;
|
|
}
|
|
id = (int)x;
|
|
}
|
|
|
|
if (dict_has_key(dict, "text"))
|
|
{
|
|
if (dict_has_key(dict, "length")
|
|
|| dict_has_key(dict, "end_col")
|
|
|| dict_has_key(dict, "end_lnum"))
|
|
{
|
|
emsg(_(e_cannot_use_length_endcol_and_endlnum_with_text));
|
|
goto theend;
|
|
}
|
|
|
|
text = dict_get_string(dict, "text", TRUE);
|
|
if (text == NULL)
|
|
goto theend;
|
|
// use a default length of 1 to make multiple props show up
|
|
end_col = start_col + 1;
|
|
|
|
if (dict_has_key(dict, "text_align"))
|
|
{
|
|
char_u *p = dict_get_string(dict, "text_align", FALSE);
|
|
|
|
if (p == NULL)
|
|
goto theend;
|
|
if (start_col != 0)
|
|
{
|
|
emsg(_(e_can_only_use_text_align_when_column_is_zero));
|
|
goto theend;
|
|
}
|
|
if (STRCMP(p, "right") == 0)
|
|
flags |= TP_FLAG_ALIGN_RIGHT;
|
|
else if (STRCMP(p, "above") == 0)
|
|
flags |= TP_FLAG_ALIGN_ABOVE;
|
|
else if (STRCMP(p, "below") == 0)
|
|
flags |= TP_FLAG_ALIGN_BELOW;
|
|
else if (STRCMP(p, "after") != 0)
|
|
{
|
|
semsg(_(e_invalid_value_for_argument_str_str), "text_align", p);
|
|
goto theend;
|
|
}
|
|
}
|
|
|
|
if (dict_has_key(dict, "text_padding_left"))
|
|
{
|
|
text_padding_left = dict_get_number(dict, "text_padding_left");
|
|
if (text_padding_left < 0)
|
|
{
|
|
semsg(_(e_argument_must_be_positive_str), "text_padding_left");
|
|
goto theend;
|
|
}
|
|
}
|
|
|
|
if (dict_has_key(dict, "text_wrap"))
|
|
{
|
|
char_u *p = dict_get_string(dict, "text_wrap", FALSE);
|
|
|
|
if (p == NULL)
|
|
goto theend;
|
|
if (STRCMP(p, "wrap") == 0)
|
|
flags |= TP_FLAG_WRAP;
|
|
else if (STRCMP(p, "truncate") != 0)
|
|
{
|
|
semsg(_(e_invalid_value_for_argument_str_str), "text_wrap", p);
|
|
goto theend;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Column must be 1 or more for a normal text property; when "text" is
|
|
// present zero means it goes after the line.
|
|
if (start_col < (text == NULL ? 1 : 0))
|
|
{
|
|
semsg(_(e_invalid_column_number_nr), (long)start_col);
|
|
goto theend;
|
|
}
|
|
if (start_col > 0 && text_padding_left > 0)
|
|
{
|
|
emsg(_(e_can_only_use_left_padding_when_column_is_zero));
|
|
goto theend;
|
|
}
|
|
|
|
if (dict_arg != NULL && get_bufnr_from_arg(dict_arg, &buf) == FAIL)
|
|
goto theend;
|
|
|
|
if (id < 0)
|
|
{
|
|
if (buf->b_textprop_text.ga_len > 0)
|
|
{
|
|
emsg(_(e_cannot_use_negative_id_after_adding_textprop_with_text));
|
|
goto theend;
|
|
}
|
|
did_use_negative_pop_id = TRUE;
|
|
}
|
|
|
|
if (text != NULL)
|
|
{
|
|
if (did_use_negative_pop_id)
|
|
{
|
|
emsg(_(e_cannot_add_textprop_with_text_after_using_textprop_with_negative_id));
|
|
goto theend;
|
|
}
|
|
id = get_textprop_id(buf);
|
|
}
|
|
|
|
// This must be done _before_ we add the property because property changes
|
|
// trigger buffer (memline) reorganisation, which needs this flag to be
|
|
// correctly set.
|
|
buf->b_has_textprop = TRUE; // this is never reset
|
|
|
|
prop_add_one(buf, type_name, id, text, text_padding_left, flags,
|
|
start_lnum, end_lnum, start_col, end_col);
|
|
text = NULL;
|
|
|
|
redraw_buf_later(buf, UPD_VALID);
|
|
|
|
theend:
|
|
vim_free(text);
|
|
return id;
|
|
}
|
|
|
|
/*
|
|
* Fetch the text properties for line "lnum" in buffer "buf".
|
|
* Returns the number of text properties and, when non-zero, a pointer to the
|
|
* first one in "props" (note that it is not aligned, therefore the char_u
|
|
* pointer).
|
|
*/
|
|
int
|
|
get_text_props(buf_T *buf, linenr_T lnum, char_u **props, int will_change)
|
|
{
|
|
char_u *text;
|
|
size_t textlen;
|
|
size_t proplen;
|
|
|
|
// Be quick when no text property types have been defined for the buffer,
|
|
// unless we are adding one.
|
|
if ((!buf->b_has_textprop && !will_change) || buf->b_ml.ml_mfp == NULL)
|
|
return 0;
|
|
|
|
// Fetch the line to get the ml_line_len field updated.
|
|
text = ml_get_buf(buf, lnum, will_change);
|
|
textlen = ml_get_buf_len(buf, lnum) + 1;
|
|
proplen = buf->b_ml.ml_line_len - textlen;
|
|
if (proplen == 0)
|
|
return 0;
|
|
if (proplen % sizeof(textprop_T) != 0)
|
|
{
|
|
iemsg(e_text_property_info_corrupted);
|
|
return 0;
|
|
}
|
|
*props = text + textlen;
|
|
return (int)(proplen / sizeof(textprop_T));
|
|
}
|
|
|
|
/*
|
|
* Return the number of text properties with "above" or "below" alignment in
|
|
* line "lnum". A "right" aligned property also goes below after a "below" or
|
|
* other "right" aligned property.
|
|
*/
|
|
int
|
|
prop_count_above_below(buf_T *buf, linenr_T lnum)
|
|
{
|
|
char_u *props;
|
|
int count = get_text_props(buf, lnum, &props, FALSE);
|
|
int result = 0;
|
|
textprop_T prop;
|
|
int i;
|
|
int next_right_goes_below = FALSE;
|
|
|
|
if (count == 0)
|
|
return 0;
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
mch_memmove(&prop, props + i * sizeof(prop), sizeof(prop));
|
|
if (prop.tp_col == MAXCOL && text_prop_type_valid(buf, &prop))
|
|
{
|
|
if ((prop.tp_flags & (TP_FLAG_ALIGN_ABOVE | TP_FLAG_ALIGN_BELOW))
|
|
|| (next_right_goes_below
|
|
&& (prop.tp_flags & TP_FLAG_ALIGN_RIGHT)))
|
|
{
|
|
++result;
|
|
}
|
|
else if (prop.tp_flags & TP_FLAG_ALIGN_RIGHT)
|
|
next_right_goes_below = TRUE;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Return the number of text properties on line "lnum" in the current buffer.
|
|
* When "only_starting" is true only text properties starting in this line will
|
|
* be considered.
|
|
* When "last_line" is FALSE then text properties after the line are not
|
|
* counted.
|
|
*/
|
|
int
|
|
count_props(linenr_T lnum, int only_starting, int last_line)
|
|
{
|
|
char_u *props;
|
|
int proplen = get_text_props(curbuf, lnum, &props, 0);
|
|
int result = proplen;
|
|
int i;
|
|
textprop_T prop;
|
|
|
|
for (i = 0; i < proplen; ++i)
|
|
{
|
|
mch_memmove(&prop, props + i * sizeof(prop), sizeof(prop));
|
|
// A prop is dropped when in the first line and it continues from the
|
|
// previous line, or when not in the last line and it is virtual text
|
|
// after the line.
|
|
if ((only_starting && (prop.tp_flags & TP_FLAG_CONT_PREV))
|
|
|| (!last_line && prop.tp_col == MAXCOL))
|
|
--result;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static textprop_T *text_prop_compare_props;
|
|
static buf_T *text_prop_compare_buf;
|
|
|
|
/*
|
|
* Score for sorting on position of the text property: 0: above,
|
|
* 1: after (default), 2: right, 3: below (comes last)
|
|
*/
|
|
static int
|
|
text_prop_order(int flags)
|
|
{
|
|
if (flags & TP_FLAG_ALIGN_ABOVE)
|
|
return 0;
|
|
if (flags & TP_FLAG_ALIGN_RIGHT)
|
|
return 2;
|
|
if (flags & TP_FLAG_ALIGN_BELOW)
|
|
return 3;
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Function passed to qsort() to sort text properties.
|
|
* Return 1 if "s1" has priority over "s2", -1 if the other way around, zero if
|
|
* both have the same priority.
|
|
*/
|
|
static int
|
|
text_prop_compare(const void *s1, const void *s2)
|
|
{
|
|
int idx1, idx2;
|
|
textprop_T *tp1, *tp2;
|
|
proptype_T *pt1, *pt2;
|
|
colnr_T col1, col2;
|
|
|
|
idx1 = *(int *)s1;
|
|
idx2 = *(int *)s2;
|
|
tp1 = &text_prop_compare_props[idx1];
|
|
tp2 = &text_prop_compare_props[idx2];
|
|
col1 = tp1->tp_col;
|
|
col2 = tp2->tp_col;
|
|
|
|
// property that inserts text has priority over one that doesn't
|
|
if ((tp1->tp_id < 0) != (tp2->tp_id < 0))
|
|
return tp1->tp_id < 0 ? 1 : -1;
|
|
|
|
if (col1 == MAXCOL || col2 == MAXCOL)
|
|
{
|
|
int order1 = text_prop_order(tp1->tp_flags);
|
|
int order2 = text_prop_order(tp2->tp_flags);
|
|
|
|
// sort on order where it is added
|
|
if (order1 != order2)
|
|
return order1 < order2 ? 1 : -1;
|
|
}
|
|
|
|
// check highest priority, defined by the type
|
|
pt1 = text_prop_type_by_id(text_prop_compare_buf, tp1->tp_type);
|
|
pt2 = text_prop_type_by_id(text_prop_compare_buf, tp2->tp_type);
|
|
if (pt1 != pt2)
|
|
{
|
|
if (pt1 == NULL)
|
|
return -1;
|
|
if (pt2 == NULL)
|
|
return 1;
|
|
if (pt1->pt_priority != pt2->pt_priority)
|
|
return pt1->pt_priority > pt2->pt_priority ? 1 : -1;
|
|
}
|
|
|
|
// same priority, one that starts first wins
|
|
if (col1 != col2)
|
|
return col1 < col2 ? 1 : -1;
|
|
|
|
// for a property with text the id can be used as tie breaker
|
|
if (tp1->tp_id < 0)
|
|
return tp1->tp_id > tp2->tp_id ? 1 : -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Sort "count" text properties using an array if indexes "idxs" into the list
|
|
* of text props "props" for buffer "buf".
|
|
*/
|
|
void
|
|
sort_text_props(
|
|
buf_T *buf,
|
|
textprop_T *props,
|
|
int *idxs,
|
|
int count)
|
|
{
|
|
text_prop_compare_buf = buf;
|
|
text_prop_compare_props = props;
|
|
qsort((void *)idxs, (size_t)count, sizeof(int), text_prop_compare);
|
|
}
|
|
|
|
/*
|
|
* Find text property "type_id" in the visible lines of window "wp".
|
|
* Match "id" when it is > 0.
|
|
* Returns FAIL when not found.
|
|
*/
|
|
int
|
|
find_visible_prop(
|
|
win_T *wp,
|
|
int type_id,
|
|
int id,
|
|
textprop_T *prop,
|
|
linenr_T *found_lnum)
|
|
{
|
|
// return when "type_id" no longer exists
|
|
if (text_prop_type_by_id(wp->w_buffer, type_id) == NULL)
|
|
return FAIL;
|
|
|
|
// w_botline may not have been updated yet.
|
|
validate_botline_win(wp);
|
|
for (linenr_T lnum = wp->w_topline; lnum < wp->w_botline; ++lnum)
|
|
{
|
|
char_u *props;
|
|
int count = get_text_props(wp->w_buffer, lnum, &props, FALSE);
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
mch_memmove(prop, props + i * sizeof(textprop_T),
|
|
sizeof(textprop_T));
|
|
if (prop->tp_type == type_id && (id <= 0 || prop->tp_id == id))
|
|
{
|
|
*found_lnum = lnum;
|
|
return OK;
|
|
}
|
|
}
|
|
}
|
|
return FAIL;
|
|
}
|
|
|
|
/*
|
|
* Set the text properties for line "lnum" to "props" with length "len".
|
|
* If "len" is zero text properties are removed, "props" is not used.
|
|
* Any existing text properties are dropped.
|
|
* Only works for the current buffer.
|
|
*/
|
|
static void
|
|
set_text_props(linenr_T lnum, char_u *props, int len)
|
|
{
|
|
char_u *text;
|
|
char_u *newtext;
|
|
int textlen;
|
|
|
|
text = ml_get(lnum);
|
|
textlen = ml_get_len(lnum) + 1;
|
|
newtext = alloc(textlen + len);
|
|
if (newtext == NULL)
|
|
return;
|
|
mch_memmove(newtext, text, textlen);
|
|
if (len > 0)
|
|
mch_memmove(newtext + textlen, props, len);
|
|
if (curbuf->b_ml.ml_flags & (ML_LINE_DIRTY | ML_ALLOCATED))
|
|
vim_free(curbuf->b_ml.ml_line_ptr);
|
|
curbuf->b_ml.ml_line_ptr = newtext;
|
|
curbuf->b_ml.ml_line_len = textlen + len;
|
|
curbuf->b_ml.ml_flags |= ML_LINE_DIRTY;
|
|
}
|
|
|
|
/*
|
|
* Add "text_props" with "text_prop_count" text properties to line "lnum".
|
|
*/
|
|
void
|
|
add_text_props(linenr_T lnum, textprop_T *text_props, int text_prop_count)
|
|
{
|
|
char_u *text;
|
|
char_u *newtext;
|
|
int proplen = text_prop_count * (int)sizeof(textprop_T);
|
|
|
|
text = ml_get(lnum);
|
|
newtext = alloc(curbuf->b_ml.ml_line_len + proplen);
|
|
if (newtext == NULL)
|
|
return;
|
|
mch_memmove(newtext, text, curbuf->b_ml.ml_line_len);
|
|
mch_memmove(newtext + curbuf->b_ml.ml_line_len, text_props, proplen);
|
|
if (curbuf->b_ml.ml_flags & (ML_LINE_DIRTY | ML_ALLOCATED))
|
|
vim_free(curbuf->b_ml.ml_line_ptr);
|
|
curbuf->b_ml.ml_line_ptr = newtext;
|
|
curbuf->b_ml.ml_line_len += proplen;
|
|
curbuf->b_ml.ml_flags |= ML_LINE_DIRTY;
|
|
}
|
|
|
|
/*
|
|
* Function passed to qsort() for sorting proptype_T on pt_id.
|
|
*/
|
|
static int
|
|
compare_pt(const void *s1, const void *s2)
|
|
{
|
|
proptype_T *tp1 = *(proptype_T **)s1;
|
|
proptype_T *tp2 = *(proptype_T **)s2;
|
|
|
|
return tp1->pt_id == tp2->pt_id ? 0 : tp1->pt_id < tp2->pt_id ? -1 : 1;
|
|
}
|
|
|
|
static proptype_T *
|
|
find_type_by_id(hashtab_T *ht, proptype_T ***array, int id)
|
|
{
|
|
int low = 0;
|
|
int high;
|
|
|
|
if (ht == NULL || ht->ht_used == 0)
|
|
return NULL;
|
|
|
|
// Make the lookup faster by creating an array with pointers to
|
|
// hashtable entries, sorted on pt_id.
|
|
if (*array == NULL)
|
|
{
|
|
long todo;
|
|
hashitem_T *hi;
|
|
int i = 0;
|
|
|
|
*array = ALLOC_MULT(proptype_T *, ht->ht_used);
|
|
if (*array == NULL)
|
|
return NULL;
|
|
todo = (long)ht->ht_used;
|
|
FOR_ALL_HASHTAB_ITEMS(ht, hi, todo)
|
|
{
|
|
if (!HASHITEM_EMPTY(hi))
|
|
{
|
|
(*array)[i++] = HI2PT(hi);
|
|
--todo;
|
|
}
|
|
}
|
|
qsort((void *)*array, ht->ht_used, sizeof(proptype_T *), compare_pt);
|
|
}
|
|
|
|
// binary search in the sorted array
|
|
high = ht->ht_used;
|
|
while (high > low)
|
|
{
|
|
int m = (high + low) / 2;
|
|
|
|
if ((*array)[m]->pt_id == id)
|
|
return (*array)[m];
|
|
if ((*array)[m]->pt_id > id)
|
|
high = m;
|
|
else
|
|
low = m + 1;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Fill 'dict' with text properties in 'prop'.
|
|
*/
|
|
static void
|
|
prop_fill_dict(dict_T *dict, textprop_T *prop, buf_T *buf)
|
|
{
|
|
proptype_T *pt;
|
|
int buflocal = TRUE;
|
|
int virtualtext_prop = prop->tp_id < 0;
|
|
|
|
dict_add_number(dict, "col", (prop->tp_col == MAXCOL) ? 0 : prop->tp_col);
|
|
if (!virtualtext_prop)
|
|
{
|
|
dict_add_number(dict, "length", prop->tp_len);
|
|
dict_add_number(dict, "id", prop->tp_id);
|
|
}
|
|
dict_add_number(dict, "start", !(prop->tp_flags & TP_FLAG_CONT_PREV));
|
|
dict_add_number(dict, "end", !(prop->tp_flags & TP_FLAG_CONT_NEXT));
|
|
|
|
pt = find_type_by_id(buf->b_proptypes, &buf->b_proparray, prop->tp_type);
|
|
if (pt == NULL)
|
|
{
|
|
pt = find_type_by_id(global_proptypes, &global_proparray,
|
|
prop->tp_type);
|
|
buflocal = FALSE;
|
|
}
|
|
if (pt != NULL)
|
|
dict_add_string(dict, "type", pt->pt_name);
|
|
|
|
if (buflocal)
|
|
dict_add_number(dict, "type_bufnr", buf->b_fnum);
|
|
else
|
|
dict_add_number(dict, "type_bufnr", 0);
|
|
if (virtualtext_prop)
|
|
{
|
|
// virtual text property
|
|
garray_T *gap = &buf->b_textprop_text;
|
|
char_u *text;
|
|
|
|
// negate the property id to get the string index
|
|
text = ((char_u **)gap->ga_data)[-prop->tp_id - 1];
|
|
dict_add_string(dict, "text", text);
|
|
|
|
// text_align
|
|
char_u *text_align = NULL;
|
|
if (prop->tp_flags & TP_FLAG_ALIGN_RIGHT)
|
|
text_align = (char_u *)"right";
|
|
else if (prop->tp_flags & TP_FLAG_ALIGN_ABOVE)
|
|
text_align = (char_u *)"above";
|
|
else if (prop->tp_flags & TP_FLAG_ALIGN_BELOW)
|
|
text_align = (char_u *)"below";
|
|
if (text_align != NULL)
|
|
dict_add_string(dict, "text_align", text_align);
|
|
|
|
// text_wrap
|
|
if (prop->tp_flags & TP_FLAG_WRAP)
|
|
dict_add_string(dict, "text_wrap", (char_u *)"wrap");
|
|
if (prop->tp_padleft != 0)
|
|
dict_add_number(dict, "text_padding_left", prop->tp_padleft);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Find a property type by ID in "buf" or globally.
|
|
* Returns NULL if not found.
|
|
*/
|
|
proptype_T *
|
|
text_prop_type_by_id(buf_T *buf, int id)
|
|
{
|
|
proptype_T *type;
|
|
|
|
type = find_type_by_id(buf->b_proptypes, &buf->b_proparray, id);
|
|
if (type == NULL)
|
|
type = find_type_by_id(global_proptypes, &global_proparray, id);
|
|
return type;
|
|
}
|
|
|
|
/*
|
|
* Return TRUE if "prop" is a valid text property type.
|
|
*/
|
|
int
|
|
text_prop_type_valid(buf_T *buf, textprop_T *prop)
|
|
{
|
|
return text_prop_type_by_id(buf, prop->tp_type) != NULL;
|
|
}
|
|
|
|
/*
|
|
* prop_clear({lnum} [, {lnum_end} [, {bufnr}]])
|
|
*/
|
|
void
|
|
f_prop_clear(typval_T *argvars, typval_T *rettv UNUSED)
|
|
{
|
|
linenr_T start;
|
|
linenr_T end;
|
|
linenr_T lnum;
|
|
buf_T *buf = curbuf;
|
|
int did_clear = FALSE;
|
|
|
|
if (in_vim9script()
|
|
&& (check_for_number_arg(argvars, 0) == FAIL
|
|
|| check_for_opt_number_arg(argvars, 1) == FAIL
|
|
|| (argvars[1].v_type != VAR_UNKNOWN
|
|
&& check_for_opt_dict_arg(argvars, 2) == FAIL)))
|
|
return;
|
|
|
|
start = tv_get_number(&argvars[0]);
|
|
end = start;
|
|
if (argvars[1].v_type != VAR_UNKNOWN)
|
|
{
|
|
end = tv_get_number(&argvars[1]);
|
|
if (argvars[2].v_type != VAR_UNKNOWN)
|
|
{
|
|
if (get_bufnr_from_arg(&argvars[2], &buf) == FAIL)
|
|
return;
|
|
}
|
|
}
|
|
if (start < 1 || end < 1)
|
|
{
|
|
emsg(_(e_invalid_range));
|
|
return;
|
|
}
|
|
|
|
for (lnum = start; lnum <= end; ++lnum)
|
|
{
|
|
char_u *text;
|
|
size_t len;
|
|
|
|
if (lnum > buf->b_ml.ml_line_count)
|
|
break;
|
|
text = ml_get_buf(buf, lnum, FALSE);
|
|
len = ml_get_buf_len(buf, lnum) + 1;
|
|
if ((size_t)buf->b_ml.ml_line_len > len)
|
|
{
|
|
did_clear = TRUE;
|
|
if (!(buf->b_ml.ml_flags & ML_LINE_DIRTY))
|
|
{
|
|
char_u *newtext = vim_strsave(text);
|
|
|
|
// need to allocate the line now
|
|
if (newtext == NULL)
|
|
return;
|
|
if (buf->b_ml.ml_flags & ML_ALLOCATED)
|
|
vim_free(buf->b_ml.ml_line_ptr);
|
|
buf->b_ml.ml_line_ptr = newtext;
|
|
buf->b_ml.ml_flags |= ML_LINE_DIRTY;
|
|
}
|
|
buf->b_ml.ml_line_len = (int)len;
|
|
}
|
|
}
|
|
if (did_clear)
|
|
redraw_buf_later(buf, UPD_NOT_VALID);
|
|
}
|
|
|
|
/*
|
|
* prop_find({props} [, {direction}])
|
|
*/
|
|
void
|
|
f_prop_find(typval_T *argvars, typval_T *rettv)
|
|
{
|
|
pos_T *cursor = &curwin->w_cursor;
|
|
dict_T *dict;
|
|
buf_T *buf = curbuf;
|
|
dictitem_T *di;
|
|
int lnum_start;
|
|
int start_pos_has_prop = 0;
|
|
int seen_end = FALSE;
|
|
int id = 0;
|
|
int id_found = FALSE;
|
|
int type_id = -1;
|
|
int skipstart = FALSE;
|
|
int lnum = -1;
|
|
int col = -1;
|
|
int dir = FORWARD; // FORWARD == 1, BACKWARD == -1
|
|
int both;
|
|
|
|
if (in_vim9script()
|
|
&& (check_for_dict_arg(argvars, 0) == FAIL
|
|
|| check_for_opt_string_arg(argvars, 1) == FAIL))
|
|
return;
|
|
|
|
if (check_for_nonnull_dict_arg(argvars, 0) == FAIL)
|
|
return;
|
|
dict = argvars[0].vval.v_dict;
|
|
|
|
if (get_bufnr_from_arg(&argvars[0], &buf) == FAIL)
|
|
return;
|
|
if (buf->b_ml.ml_mfp == NULL)
|
|
return;
|
|
|
|
if (argvars[1].v_type != VAR_UNKNOWN)
|
|
{
|
|
char_u *dir_s = tv_get_string(&argvars[1]);
|
|
|
|
if (*dir_s == 'b')
|
|
dir = BACKWARD;
|
|
else if (*dir_s != 'f')
|
|
{
|
|
emsg(_(e_invalid_argument));
|
|
return;
|
|
}
|
|
}
|
|
|
|
di = dict_find(dict, (char_u *)"lnum", -1);
|
|
if (di != NULL)
|
|
lnum = tv_get_number(&di->di_tv);
|
|
|
|
di = dict_find(dict, (char_u *)"col", -1);
|
|
if (di != NULL)
|
|
col = tv_get_number(&di->di_tv);
|
|
|
|
if (lnum == -1)
|
|
{
|
|
lnum = cursor->lnum;
|
|
col = cursor->col + 1;
|
|
}
|
|
else if (col == -1)
|
|
col = 1;
|
|
|
|
if (lnum < 1 || lnum > buf->b_ml.ml_line_count)
|
|
{
|
|
emsg(_(e_invalid_range));
|
|
return;
|
|
}
|
|
|
|
skipstart = dict_get_bool(dict, "skipstart", 0);
|
|
|
|
if (dict_has_key(dict, "id"))
|
|
{
|
|
id = dict_get_number(dict, "id");
|
|
id_found = TRUE;
|
|
}
|
|
if (dict_has_key(dict, "type"))
|
|
{
|
|
char_u *name = dict_get_string(dict, "type", FALSE);
|
|
proptype_T *type = lookup_prop_type(name, buf);
|
|
|
|
if (type == NULL)
|
|
return;
|
|
type_id = type->pt_id;
|
|
}
|
|
both = dict_get_bool(dict, "both", FALSE);
|
|
if (!id_found && type_id == -1)
|
|
{
|
|
emsg(_(e_need_at_least_one_of_id_or_type));
|
|
return;
|
|
}
|
|
if (both && (!id_found || type_id == -1))
|
|
{
|
|
emsg(_(e_need_id_and_type_or_types_with_both));
|
|
return;
|
|
}
|
|
|
|
lnum_start = lnum;
|
|
|
|
if (rettv_dict_alloc(rettv) == FAIL)
|
|
return;
|
|
|
|
while (1)
|
|
{
|
|
char_u *text = ml_get_buf(buf, lnum, FALSE);
|
|
size_t textlen = ml_get_buf_len(buf, lnum) + 1;
|
|
int count = (int)((buf->b_ml.ml_line_len - textlen)
|
|
/ sizeof(textprop_T));
|
|
int i;
|
|
textprop_T prop;
|
|
int prop_start;
|
|
int prop_end;
|
|
|
|
for (i = dir == BACKWARD ? count - 1 : 0; i >= 0 && i < count; i += dir)
|
|
{
|
|
mch_memmove(&prop, text + textlen + i * sizeof(textprop_T),
|
|
sizeof(textprop_T));
|
|
|
|
// For the very first line try to find the first property before or
|
|
// after `col`, depending on the search direction.
|
|
if (lnum == lnum_start)
|
|
{
|
|
if (dir == BACKWARD)
|
|
{
|
|
if (prop.tp_col > col)
|
|
continue;
|
|
}
|
|
else if (prop.tp_col + prop.tp_len - (prop.tp_len != 0) < col)
|
|
continue;
|
|
}
|
|
if (both ? prop.tp_id == id && prop.tp_type == type_id
|
|
: (id_found && prop.tp_id == id)
|
|
|| prop.tp_type == type_id)
|
|
{
|
|
// Check if the starting position has text props.
|
|
if (lnum_start == lnum
|
|
&& col >= prop.tp_col
|
|
&& (col <= prop.tp_col + prop.tp_len
|
|
- (prop.tp_len != 0)))
|
|
start_pos_has_prop = 1;
|
|
|
|
// The property was not continued from last line, it starts on
|
|
// this line.
|
|
prop_start = !(prop.tp_flags & TP_FLAG_CONT_PREV);
|
|
// The property does not continue on the next line, it ends on
|
|
// this line.
|
|
prop_end = !(prop.tp_flags & TP_FLAG_CONT_NEXT);
|
|
if (!prop_start && prop_end && dir == FORWARD)
|
|
seen_end = 1;
|
|
|
|
// Skip lines without the start flag.
|
|
if (!prop_start)
|
|
{
|
|
// Always search backwards for start when search started
|
|
// on a prop and we're not skipping.
|
|
if (start_pos_has_prop && !skipstart)
|
|
dir = BACKWARD;
|
|
continue;
|
|
}
|
|
|
|
// If skipstart is true, skip the prop at start pos (even if
|
|
// continued from another line).
|
|
if (start_pos_has_prop && skipstart && !seen_end)
|
|
{
|
|
start_pos_has_prop = 0;
|
|
continue;
|
|
}
|
|
|
|
prop_fill_dict(rettv->vval.v_dict, &prop, buf);
|
|
dict_add_number(rettv->vval.v_dict, "lnum", lnum);
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (dir > 0)
|
|
{
|
|
if (lnum >= buf->b_ml.ml_line_count)
|
|
break;
|
|
lnum++;
|
|
}
|
|
else
|
|
{
|
|
if (lnum <= 1)
|
|
break;
|
|
lnum--;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Returns TRUE if 'type_or_id' is in the 'types_or_ids' list.
|
|
*/
|
|
static int
|
|
prop_type_or_id_in_list(int *types_or_ids, int len, int type_or_id)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < len; i++)
|
|
if (types_or_ids[i] == type_or_id)
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* Return all the text properties in line 'lnum' in buffer 'buf' in 'retlist'.
|
|
* If 'prop_types' is not NULL, then return only the text properties with
|
|
* matching property type in the 'prop_types' array.
|
|
* If 'prop_ids' is not NULL, then return only the text properties with
|
|
* an identifier in the 'props_ids' array.
|
|
* If 'add_lnum' is TRUE, then add the line number also to the text property
|
|
* dictionary.
|
|
*/
|
|
static void
|
|
get_props_in_line(
|
|
buf_T *buf,
|
|
linenr_T lnum,
|
|
int *prop_types,
|
|
int prop_types_len,
|
|
int *prop_ids,
|
|
int prop_ids_len,
|
|
list_T *retlist,
|
|
int add_lnum)
|
|
{
|
|
char_u *text = ml_get_buf(buf, lnum, FALSE);
|
|
size_t textlen = ml_get_buf_len(buf, lnum) + 1;
|
|
int count;
|
|
int i;
|
|
textprop_T prop;
|
|
|
|
count = (int)((buf->b_ml.ml_line_len - textlen) / sizeof(textprop_T));
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
mch_memmove(&prop, text + textlen + i * sizeof(textprop_T),
|
|
sizeof(textprop_T));
|
|
if ((prop_types == NULL
|
|
|| prop_type_or_id_in_list(prop_types, prop_types_len,
|
|
prop.tp_type))
|
|
&& (prop_ids == NULL
|
|
|| prop_type_or_id_in_list(prop_ids, prop_ids_len,
|
|
prop.tp_id)))
|
|
{
|
|
dict_T *d = dict_alloc();
|
|
|
|
if (d == NULL)
|
|
break;
|
|
prop_fill_dict(d, &prop, buf);
|
|
if (add_lnum)
|
|
dict_add_number(d, "lnum", lnum);
|
|
list_append_dict(retlist, d);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Convert a List of property type names into an array of property type
|
|
* identifiers. Returns a pointer to the allocated array. Returns NULL on
|
|
* error. 'num_types' is set to the number of returned property types.
|
|
*/
|
|
static int *
|
|
get_prop_types_from_names(list_T *l, buf_T *buf, int *num_types)
|
|
{
|
|
int *prop_types;
|
|
listitem_T *li;
|
|
int i;
|
|
char_u *name;
|
|
proptype_T *type;
|
|
|
|
*num_types = 0;
|
|
|
|
prop_types = ALLOC_MULT(int, list_len(l));
|
|
if (prop_types == NULL)
|
|
return NULL;
|
|
|
|
i = 0;
|
|
FOR_ALL_LIST_ITEMS(l, li)
|
|
{
|
|
if (li->li_tv.v_type != VAR_STRING)
|
|
{
|
|
emsg(_(e_string_required));
|
|
goto errret;
|
|
}
|
|
name = li->li_tv.vval.v_string;
|
|
if (name == NULL)
|
|
goto errret;
|
|
|
|
type = lookup_prop_type(name, buf);
|
|
if (type == NULL)
|
|
goto errret;
|
|
prop_types[i++] = type->pt_id;
|
|
}
|
|
|
|
*num_types = i;
|
|
return prop_types;
|
|
|
|
errret:
|
|
VIM_CLEAR(prop_types);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Convert a List of property identifiers into an array of property
|
|
* identifiers. Returns a pointer to the allocated array. Returns NULL on
|
|
* error. 'num_ids' is set to the number of returned property identifiers.
|
|
*/
|
|
static int *
|
|
get_prop_ids_from_list(list_T *l, int *num_ids)
|
|
{
|
|
int *prop_ids;
|
|
listitem_T *li;
|
|
int i;
|
|
int id;
|
|
int error;
|
|
|
|
*num_ids = 0;
|
|
|
|
prop_ids = ALLOC_MULT(int, list_len(l));
|
|
if (prop_ids == NULL)
|
|
return NULL;
|
|
|
|
i = 0;
|
|
FOR_ALL_LIST_ITEMS(l, li)
|
|
{
|
|
error = FALSE;
|
|
id = tv_get_number_chk(&li->li_tv, &error);
|
|
if (error)
|
|
goto errret;
|
|
|
|
prop_ids[i++] = id;
|
|
}
|
|
|
|
*num_ids = i;
|
|
return prop_ids;
|
|
|
|
errret:
|
|
VIM_CLEAR(prop_ids);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* prop_list({lnum} [, {bufnr}])
|
|
*/
|
|
void
|
|
f_prop_list(typval_T *argvars, typval_T *rettv)
|
|
{
|
|
linenr_T lnum;
|
|
linenr_T start_lnum;
|
|
linenr_T end_lnum;
|
|
buf_T *buf = curbuf;
|
|
int add_lnum = FALSE;
|
|
int *prop_types = NULL;
|
|
int prop_types_len = 0;
|
|
int *prop_ids = NULL;
|
|
int prop_ids_len = 0;
|
|
list_T *l;
|
|
dictitem_T *di;
|
|
|
|
if (in_vim9script()
|
|
&& (check_for_number_arg(argvars, 0) == FAIL
|
|
|| check_for_opt_dict_arg(argvars, 1) == FAIL))
|
|
return;
|
|
|
|
if (rettv_list_alloc(rettv) == FAIL)
|
|
return;
|
|
|
|
// default: get text properties on current line
|
|
start_lnum = tv_get_number(&argvars[0]);
|
|
end_lnum = start_lnum;
|
|
if (argvars[1].v_type != VAR_UNKNOWN)
|
|
{
|
|
dict_T *d;
|
|
|
|
if (check_for_dict_arg(argvars, 1) == FAIL)
|
|
return;
|
|
d = argvars[1].vval.v_dict;
|
|
|
|
if (get_bufnr_from_arg(&argvars[1], &buf) == FAIL)
|
|
return;
|
|
|
|
if (d != NULL && (di = dict_find(d, (char_u *)"end_lnum", -1)) != NULL)
|
|
{
|
|
if (di->di_tv.v_type != VAR_NUMBER)
|
|
{
|
|
emsg(_(e_number_required));
|
|
return;
|
|
}
|
|
end_lnum = tv_get_number(&di->di_tv);
|
|
if (end_lnum < 0)
|
|
// negative end_lnum is used as an offset from the last buffer
|
|
// line
|
|
end_lnum = buf->b_ml.ml_line_count + end_lnum + 1;
|
|
else if (end_lnum > buf->b_ml.ml_line_count)
|
|
end_lnum = buf->b_ml.ml_line_count;
|
|
add_lnum = TRUE;
|
|
}
|
|
if (d != NULL && (di = dict_find(d, (char_u *)"types", -1)) != NULL)
|
|
{
|
|
if (di->di_tv.v_type != VAR_LIST)
|
|
{
|
|
emsg(_(e_list_required));
|
|
return;
|
|
}
|
|
|
|
l = di->di_tv.vval.v_list;
|
|
if (l != NULL && list_len(l) > 0)
|
|
{
|
|
prop_types = get_prop_types_from_names(l, buf, &prop_types_len);
|
|
if (prop_types == NULL)
|
|
return;
|
|
}
|
|
}
|
|
if (d != NULL && (di = dict_find(d, (char_u *)"ids", -1)) != NULL)
|
|
{
|
|
if (di->di_tv.v_type != VAR_LIST)
|
|
{
|
|
emsg(_(e_list_required));
|
|
goto errret;
|
|
}
|
|
|
|
l = di->di_tv.vval.v_list;
|
|
if (l != NULL && list_len(l) > 0)
|
|
{
|
|
prop_ids = get_prop_ids_from_list(l, &prop_ids_len);
|
|
if (prop_ids == NULL)
|
|
goto errret;
|
|
}
|
|
}
|
|
}
|
|
if (start_lnum < 1 || start_lnum > buf->b_ml.ml_line_count
|
|
|| end_lnum < 1 || end_lnum < start_lnum)
|
|
emsg(_(e_invalid_range));
|
|
else
|
|
for (lnum = start_lnum; lnum <= end_lnum; lnum++)
|
|
get_props_in_line(buf, lnum, prop_types, prop_types_len,
|
|
prop_ids, prop_ids_len,
|
|
rettv->vval.v_list, add_lnum);
|
|
|
|
errret:
|
|
VIM_CLEAR(prop_types);
|
|
VIM_CLEAR(prop_ids);
|
|
}
|
|
|
|
/*
|
|
* prop_remove({props} [, {lnum} [, {lnum_end}]])
|
|
*/
|
|
void
|
|
f_prop_remove(typval_T *argvars, typval_T *rettv)
|
|
{
|
|
linenr_T start = 1;
|
|
linenr_T end = 0;
|
|
linenr_T lnum;
|
|
linenr_T first_changed = 0;
|
|
linenr_T last_changed = 0;
|
|
dict_T *dict;
|
|
buf_T *buf = curbuf;
|
|
int do_all;
|
|
int id = -MAXCOL;
|
|
int type_id = -1; // for a single "type"
|
|
int *type_ids = NULL; // array, for a list of "types", allocated
|
|
int num_type_ids = 0; // number of elements in "type_ids"
|
|
int both;
|
|
int did_remove_text = FALSE;
|
|
|
|
rettv->vval.v_number = 0;
|
|
|
|
if (in_vim9script()
|
|
&& (check_for_dict_arg(argvars, 0) == FAIL
|
|
|| check_for_opt_number_arg(argvars, 1) == FAIL
|
|
|| (argvars[1].v_type != VAR_UNKNOWN
|
|
&& check_for_opt_number_arg(argvars, 2) == FAIL)))
|
|
return;
|
|
|
|
if (check_for_nonnull_dict_arg(argvars, 0) == FAIL)
|
|
return;
|
|
|
|
if (argvars[1].v_type != VAR_UNKNOWN)
|
|
{
|
|
start = tv_get_number(&argvars[1]);
|
|
end = start;
|
|
if (argvars[2].v_type != VAR_UNKNOWN)
|
|
end = tv_get_number(&argvars[2]);
|
|
if (start < 1 || end < 1)
|
|
{
|
|
emsg(_(e_invalid_range));
|
|
return;
|
|
}
|
|
}
|
|
|
|
dict = argvars[0].vval.v_dict;
|
|
if (get_bufnr_from_arg(&argvars[0], &buf) == FAIL)
|
|
return;
|
|
if (buf->b_ml.ml_mfp == NULL)
|
|
return;
|
|
|
|
do_all = dict_get_bool(dict, "all", FALSE);
|
|
|
|
if (dict_has_key(dict, "id"))
|
|
id = dict_get_number(dict, "id");
|
|
|
|
// if a specific type was supplied "type": check that (and ignore "types".
|
|
// Otherwise check against the list of "types".
|
|
if (dict_has_key(dict, "type"))
|
|
{
|
|
char_u *name = dict_get_string(dict, "type", FALSE);
|
|
proptype_T *type = lookup_prop_type(name, buf);
|
|
|
|
if (type == NULL)
|
|
return;
|
|
type_id = type->pt_id;
|
|
}
|
|
if (dict_has_key(dict, "types"))
|
|
{
|
|
typval_T types;
|
|
listitem_T *li = NULL;
|
|
|
|
dict_get_tv(dict, "types", &types);
|
|
if (types.v_type == VAR_LIST && types.vval.v_list->lv_len > 0)
|
|
{
|
|
type_ids = alloc( sizeof(int) * types.vval.v_list->lv_len );
|
|
|
|
FOR_ALL_LIST_ITEMS(types.vval.v_list, li)
|
|
{
|
|
proptype_T *prop_type;
|
|
|
|
if (li->li_tv.v_type != VAR_STRING)
|
|
continue;
|
|
|
|
prop_type = lookup_prop_type(li->li_tv.vval.v_string, buf);
|
|
|
|
if (!prop_type)
|
|
goto cleanup_prop_remove;
|
|
|
|
type_ids[num_type_ids++] = prop_type->pt_id;
|
|
}
|
|
}
|
|
}
|
|
both = dict_get_bool(dict, "both", FALSE);
|
|
|
|
if (id == -MAXCOL && (type_id == -1 && num_type_ids == 0))
|
|
{
|
|
emsg(_(e_need_at_least_one_of_id_or_type));
|
|
goto cleanup_prop_remove;
|
|
}
|
|
if (both && (id == -MAXCOL || (type_id == -1 && num_type_ids == 0)))
|
|
{
|
|
emsg(_(e_need_id_and_type_or_types_with_both));
|
|
goto cleanup_prop_remove;
|
|
}
|
|
if (type_id != -1 && num_type_ids > 0)
|
|
{
|
|
emsg(_(e_cannot_specify_both_type_and_types));
|
|
goto cleanup_prop_remove;
|
|
}
|
|
|
|
if (end == 0)
|
|
end = buf->b_ml.ml_line_count;
|
|
for (lnum = start; lnum <= end; ++lnum)
|
|
{
|
|
size_t len;
|
|
|
|
if (lnum > buf->b_ml.ml_line_count)
|
|
break;
|
|
len = ml_get_buf_len(buf, lnum) + 1;
|
|
if ((size_t)buf->b_ml.ml_line_len > len)
|
|
{
|
|
static textprop_T textprop; // static because of alignment
|
|
unsigned idx;
|
|
|
|
for (idx = 0; idx < (buf->b_ml.ml_line_len - len)
|
|
/ sizeof(textprop_T); ++idx)
|
|
{
|
|
char_u *cur_prop = buf->b_ml.ml_line_ptr + len
|
|
+ idx * sizeof(textprop_T);
|
|
size_t taillen;
|
|
int matches_id = 0;
|
|
int matches_type = 0;
|
|
|
|
mch_memmove(&textprop, cur_prop, sizeof(textprop_T));
|
|
|
|
matches_id = textprop.tp_id == id;
|
|
if (num_type_ids > 0)
|
|
{
|
|
int idx2;
|
|
|
|
for (idx2 = 0; !matches_type && idx2 < num_type_ids; ++idx2)
|
|
matches_type = textprop.tp_type == type_ids[idx2];
|
|
}
|
|
else
|
|
{
|
|
matches_type = textprop.tp_type == type_id;
|
|
}
|
|
|
|
if (both ? matches_id && matches_type
|
|
: matches_id || matches_type)
|
|
{
|
|
if (!(buf->b_ml.ml_flags & ML_LINE_DIRTY))
|
|
{
|
|
char_u *newptr = alloc(buf->b_ml.ml_line_len);
|
|
|
|
// need to allocate the line to be able to change it
|
|
if (newptr == NULL)
|
|
goto cleanup_prop_remove;
|
|
mch_memmove(newptr, buf->b_ml.ml_line_ptr,
|
|
buf->b_ml.ml_line_len);
|
|
if (buf->b_ml.ml_flags & ML_ALLOCATED)
|
|
vim_free(buf->b_ml.ml_line_ptr);
|
|
buf->b_ml.ml_line_ptr = newptr;
|
|
buf->b_ml.ml_flags |= ML_LINE_DIRTY;
|
|
|
|
cur_prop = buf->b_ml.ml_line_ptr + len
|
|
+ idx * sizeof(textprop_T);
|
|
}
|
|
|
|
taillen = buf->b_ml.ml_line_len - len
|
|
- (idx + 1) * sizeof(textprop_T);
|
|
if (taillen > 0)
|
|
mch_memmove(cur_prop, cur_prop + sizeof(textprop_T),
|
|
taillen);
|
|
buf->b_ml.ml_line_len -= sizeof(textprop_T);
|
|
--idx;
|
|
|
|
if (textprop.tp_id < 0)
|
|
{
|
|
garray_T *gap = &buf->b_textprop_text;
|
|
int ii = -textprop.tp_id - 1;
|
|
|
|
// negative ID: property with text - free the text
|
|
if (ii < gap->ga_len)
|
|
{
|
|
char_u **p = ((char_u **)gap->ga_data) + ii;
|
|
VIM_CLEAR(*p);
|
|
did_remove_text = TRUE;
|
|
}
|
|
}
|
|
|
|
if (first_changed == 0)
|
|
first_changed = lnum;
|
|
last_changed = lnum;
|
|
++rettv->vval.v_number;
|
|
if (!do_all)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (first_changed > 0)
|
|
{
|
|
changed_line_display_buf(buf);
|
|
changed_lines_buf(buf, first_changed, last_changed + 1, 0);
|
|
redraw_buf_later(buf, UPD_VALID);
|
|
}
|
|
|
|
if (did_remove_text)
|
|
{
|
|
garray_T *gap = &buf->b_textprop_text;
|
|
|
|
// Reduce the growarray size for NULL pointers at the end.
|
|
while (gap->ga_len > 0
|
|
&& ((char_u **)gap->ga_data)[gap->ga_len - 1] == NULL)
|
|
--gap->ga_len;
|
|
}
|
|
|
|
cleanup_prop_remove:
|
|
vim_free(type_ids);
|
|
}
|
|
|
|
/*
|
|
* Common for f_prop_type_add() and f_prop_type_change().
|
|
*/
|
|
static void
|
|
prop_type_set(typval_T *argvars, int add)
|
|
{
|
|
char_u *name;
|
|
buf_T *buf = NULL;
|
|
dict_T *dict;
|
|
dictitem_T *di;
|
|
proptype_T *prop;
|
|
|
|
if (in_vim9script()
|
|
&& (check_for_string_arg(argvars, 0) == FAIL
|
|
|| check_for_dict_arg(argvars, 1) == FAIL))
|
|
return;
|
|
|
|
name = tv_get_string(&argvars[0]);
|
|
if (*name == NUL)
|
|
{
|
|
semsg(_(e_invalid_argument_str), "\"\"");
|
|
return;
|
|
}
|
|
|
|
if (get_bufnr_from_arg(&argvars[1], &buf) == FAIL)
|
|
return;
|
|
dict = argvars[1].vval.v_dict;
|
|
|
|
prop = find_prop_type(name, buf);
|
|
if (add)
|
|
{
|
|
hashtab_T **htp;
|
|
|
|
if (prop != NULL)
|
|
{
|
|
semsg(_(e_property_type_str_already_defined), name);
|
|
return;
|
|
}
|
|
prop = alloc_clear(offsetof(proptype_T, pt_name) + STRLEN(name) + 1);
|
|
if (prop == NULL)
|
|
return;
|
|
STRCPY(prop->pt_name, name);
|
|
prop->pt_id = ++proptype_id;
|
|
prop->pt_flags = PT_FLAG_COMBINE;
|
|
if (buf == NULL)
|
|
{
|
|
htp = &global_proptypes;
|
|
VIM_CLEAR(global_proparray);
|
|
}
|
|
else
|
|
{
|
|
htp = &buf->b_proptypes;
|
|
VIM_CLEAR(buf->b_proparray);
|
|
}
|
|
if (*htp == NULL)
|
|
{
|
|
*htp = ALLOC_ONE(hashtab_T);
|
|
if (*htp == NULL)
|
|
{
|
|
vim_free(prop);
|
|
return;
|
|
}
|
|
hash_init(*htp);
|
|
}
|
|
hash_add(*htp, PT2HIKEY(prop), "prop type");
|
|
}
|
|
else
|
|
{
|
|
if (prop == NULL)
|
|
{
|
|
semsg(_(e_property_type_str_does_not_exist), name);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (dict != NULL)
|
|
{
|
|
di = dict_find(dict, (char_u *)"highlight", -1);
|
|
if (di != NULL)
|
|
{
|
|
char_u *highlight;
|
|
int hl_id = 0;
|
|
|
|
highlight = dict_get_string(dict, "highlight", FALSE);
|
|
if (highlight != NULL && *highlight != NUL)
|
|
hl_id = syn_name2id(highlight);
|
|
if (hl_id <= 0)
|
|
{
|
|
semsg(_(e_unknown_highlight_group_name_str),
|
|
highlight == NULL ? (char_u *)"" : highlight);
|
|
return;
|
|
}
|
|
prop->pt_hl_id = hl_id;
|
|
}
|
|
|
|
di = dict_find(dict, (char_u *)"combine", -1);
|
|
if (di != NULL)
|
|
{
|
|
if (tv_get_bool(&di->di_tv))
|
|
prop->pt_flags |= PT_FLAG_COMBINE;
|
|
else
|
|
prop->pt_flags &= ~PT_FLAG_COMBINE;
|
|
}
|
|
|
|
di = dict_find(dict, (char_u *)"override", -1);
|
|
if (di != NULL)
|
|
{
|
|
if (tv_get_bool(&di->di_tv))
|
|
prop->pt_flags |= PT_FLAG_OVERRIDE;
|
|
else
|
|
prop->pt_flags &= ~PT_FLAG_OVERRIDE;
|
|
}
|
|
|
|
di = dict_find(dict, (char_u *)"priority", -1);
|
|
if (di != NULL)
|
|
prop->pt_priority = tv_get_number(&di->di_tv);
|
|
|
|
di = dict_find(dict, (char_u *)"start_incl", -1);
|
|
if (di != NULL)
|
|
{
|
|
if (tv_get_bool(&di->di_tv))
|
|
prop->pt_flags |= PT_FLAG_INS_START_INCL;
|
|
else
|
|
prop->pt_flags &= ~PT_FLAG_INS_START_INCL;
|
|
}
|
|
|
|
di = dict_find(dict, (char_u *)"end_incl", -1);
|
|
if (di != NULL)
|
|
{
|
|
if (tv_get_bool(&di->di_tv))
|
|
prop->pt_flags |= PT_FLAG_INS_END_INCL;
|
|
else
|
|
prop->pt_flags &= ~PT_FLAG_INS_END_INCL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* prop_type_add({name}, {props})
|
|
*/
|
|
void
|
|
f_prop_type_add(typval_T *argvars, typval_T *rettv UNUSED)
|
|
{
|
|
prop_type_set(argvars, TRUE);
|
|
}
|
|
|
|
/*
|
|
* prop_type_change({name}, {props})
|
|
*/
|
|
void
|
|
f_prop_type_change(typval_T *argvars, typval_T *rettv UNUSED)
|
|
{
|
|
prop_type_set(argvars, FALSE);
|
|
}
|
|
|
|
/*
|
|
* prop_type_delete({name} [, {bufnr}])
|
|
*/
|
|
void
|
|
f_prop_type_delete(typval_T *argvars, typval_T *rettv UNUSED)
|
|
{
|
|
char_u *name;
|
|
buf_T *buf = NULL;
|
|
hashitem_T *hi;
|
|
|
|
if (in_vim9script()
|
|
&& (check_for_string_arg(argvars, 0) == FAIL
|
|
|| check_for_opt_dict_arg(argvars, 1) == FAIL))
|
|
return;
|
|
|
|
name = tv_get_string(&argvars[0]);
|
|
if (*name == NUL)
|
|
{
|
|
semsg(_(e_invalid_argument_str), "\"\"");
|
|
return;
|
|
}
|
|
|
|
if (argvars[1].v_type != VAR_UNKNOWN)
|
|
{
|
|
if (get_bufnr_from_arg(&argvars[1], &buf) == FAIL)
|
|
return;
|
|
}
|
|
|
|
hi = find_prop_type_hi(name, buf);
|
|
if (hi == NULL)
|
|
return;
|
|
|
|
hashtab_T *ht;
|
|
proptype_T *prop = HI2PT(hi);
|
|
|
|
if (buf == NULL)
|
|
{
|
|
ht = global_proptypes;
|
|
VIM_CLEAR(global_proparray);
|
|
}
|
|
else
|
|
{
|
|
ht = buf->b_proptypes;
|
|
VIM_CLEAR(buf->b_proparray);
|
|
}
|
|
hash_remove(ht, hi, "prop type delete");
|
|
vim_free(prop);
|
|
|
|
// currently visible text properties will disappear
|
|
redraw_all_later(UPD_CLEAR);
|
|
changed_window_setting_buf(buf == NULL ? curbuf : buf);
|
|
}
|
|
|
|
/*
|
|
* prop_type_get({name} [, {props}])
|
|
*/
|
|
void
|
|
f_prop_type_get(typval_T *argvars, typval_T *rettv)
|
|
{
|
|
char_u *name;
|
|
|
|
if (in_vim9script()
|
|
&& (check_for_string_arg(argvars, 0) == FAIL
|
|
|| check_for_opt_dict_arg(argvars, 1) == FAIL))
|
|
return;
|
|
|
|
name = tv_get_string(&argvars[0]);
|
|
if (*name == NUL)
|
|
{
|
|
semsg(_(e_invalid_argument_str), "\"\"");
|
|
return;
|
|
}
|
|
|
|
if (rettv_dict_alloc(rettv) == FAIL)
|
|
return;
|
|
|
|
proptype_T *prop = NULL;
|
|
buf_T *buf = NULL;
|
|
|
|
if (argvars[1].v_type != VAR_UNKNOWN)
|
|
{
|
|
if (get_bufnr_from_arg(&argvars[1], &buf) == FAIL)
|
|
return;
|
|
}
|
|
|
|
prop = find_prop_type(name, buf);
|
|
if (prop == NULL)
|
|
return;
|
|
|
|
dict_T *d = rettv->vval.v_dict;
|
|
|
|
if (prop->pt_hl_id > 0)
|
|
dict_add_string(d, "highlight", syn_id2name(prop->pt_hl_id));
|
|
dict_add_number(d, "priority", prop->pt_priority);
|
|
dict_add_number(d, "combine",
|
|
(prop->pt_flags & PT_FLAG_COMBINE) ? 1 : 0);
|
|
dict_add_number(d, "start_incl",
|
|
(prop->pt_flags & PT_FLAG_INS_START_INCL) ? 1 : 0);
|
|
dict_add_number(d, "end_incl",
|
|
(prop->pt_flags & PT_FLAG_INS_END_INCL) ? 1 : 0);
|
|
if (buf != NULL)
|
|
dict_add_number(d, "bufnr", buf->b_fnum);
|
|
}
|
|
|
|
static void
|
|
list_types(hashtab_T *ht, list_T *l)
|
|
{
|
|
long todo;
|
|
hashitem_T *hi;
|
|
|
|
todo = (long)ht->ht_used;
|
|
FOR_ALL_HASHTAB_ITEMS(ht, hi, todo)
|
|
{
|
|
if (!HASHITEM_EMPTY(hi))
|
|
{
|
|
proptype_T *prop = HI2PT(hi);
|
|
|
|
list_append_string(l, prop->pt_name, -1);
|
|
--todo;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* prop_type_list([{bufnr}])
|
|
*/
|
|
void
|
|
f_prop_type_list(typval_T *argvars, typval_T *rettv)
|
|
{
|
|
buf_T *buf = NULL;
|
|
|
|
if (rettv_list_alloc(rettv) == FAIL)
|
|
return;
|
|
|
|
if (in_vim9script() && check_for_opt_dict_arg(argvars, 0) == FAIL)
|
|
return;
|
|
|
|
if (argvars[0].v_type != VAR_UNKNOWN)
|
|
{
|
|
if (get_bufnr_from_arg(&argvars[0], &buf) == FAIL)
|
|
return;
|
|
}
|
|
if (buf == NULL)
|
|
{
|
|
if (global_proptypes != NULL)
|
|
list_types(global_proptypes, rettv->vval.v_list);
|
|
}
|
|
else if (buf->b_proptypes != NULL)
|
|
list_types(buf->b_proptypes, rettv->vval.v_list);
|
|
}
|
|
|
|
/*
|
|
* Free all property types in "ht".
|
|
*/
|
|
static void
|
|
clear_ht_prop_types(hashtab_T *ht)
|
|
{
|
|
long todo;
|
|
hashitem_T *hi;
|
|
|
|
if (ht == NULL)
|
|
return;
|
|
|
|
todo = (long)ht->ht_used;
|
|
FOR_ALL_HASHTAB_ITEMS(ht, hi, todo)
|
|
{
|
|
if (!HASHITEM_EMPTY(hi))
|
|
{
|
|
proptype_T *prop = HI2PT(hi);
|
|
|
|
vim_free(prop);
|
|
--todo;
|
|
}
|
|
}
|
|
|
|
hash_clear(ht);
|
|
vim_free(ht);
|
|
}
|
|
|
|
#if defined(EXITFREE) || defined(PROTO)
|
|
/*
|
|
* Free all global property types.
|
|
*/
|
|
void
|
|
clear_global_prop_types(void)
|
|
{
|
|
clear_ht_prop_types(global_proptypes);
|
|
global_proptypes = NULL;
|
|
VIM_CLEAR(global_proparray);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Free all property types for "buf".
|
|
*/
|
|
void
|
|
clear_buf_prop_types(buf_T *buf)
|
|
{
|
|
clear_ht_prop_types(buf->b_proptypes);
|
|
buf->b_proptypes = NULL;
|
|
VIM_CLEAR(buf->b_proparray);
|
|
}
|
|
|
|
// Struct used to return two values from adjust_prop().
|
|
typedef struct
|
|
{
|
|
int dirty; // if the property was changed
|
|
int can_drop; // whether after this change, the prop may be removed
|
|
} adjustres_T;
|
|
|
|
/*
|
|
* Adjust the property for "added" bytes (can be negative) inserted at "col".
|
|
*
|
|
* Note that "col" is zero-based, while tp_col is one-based.
|
|
* Only for the current buffer.
|
|
* "flags" can have:
|
|
* APC_SUBSTITUTE: Text is replaced, not inserted.
|
|
* APC_INDENT: Text is inserted before virtual text prop
|
|
*/
|
|
static adjustres_T
|
|
adjust_prop(
|
|
textprop_T *prop,
|
|
colnr_T col,
|
|
int added,
|
|
int flags)
|
|
{
|
|
proptype_T *pt;
|
|
int start_incl;
|
|
int end_incl;
|
|
int droppable;
|
|
adjustres_T res = {TRUE, FALSE};
|
|
|
|
// prop after end of the line doesn't move
|
|
if (prop->tp_col == MAXCOL)
|
|
{
|
|
res.dirty = FALSE;
|
|
return res;
|
|
}
|
|
|
|
pt = text_prop_type_by_id(curbuf, prop->tp_type);
|
|
start_incl = (pt != NULL && (pt->pt_flags & PT_FLAG_INS_START_INCL))
|
|
|| (flags & APC_SUBSTITUTE)
|
|
|| (prop->tp_flags & TP_FLAG_CONT_PREV);
|
|
if (prop->tp_id < 0 && (flags & APC_INDENT))
|
|
// when inserting indent just before a character with virtual text
|
|
// shift the text property
|
|
start_incl = FALSE;
|
|
end_incl = (pt != NULL && (pt->pt_flags & PT_FLAG_INS_END_INCL))
|
|
|| (prop->tp_flags & TP_FLAG_CONT_NEXT);
|
|
// do not drop zero-width props if they later can increase in size
|
|
droppable = !(start_incl || end_incl);
|
|
|
|
if (added > 0)
|
|
{
|
|
if (col + 1 <= prop->tp_col
|
|
- (start_incl || (prop->tp_len == 0 && end_incl)))
|
|
// Change is entirely before the text property: Only shift
|
|
prop->tp_col += added;
|
|
else if (col + 1 < prop->tp_col + prop->tp_len + end_incl)
|
|
// Insertion was inside text property
|
|
prop->tp_len += added;
|
|
}
|
|
else if (prop->tp_col > col + 1)
|
|
{
|
|
if (prop->tp_col + added < col + 1)
|
|
{
|
|
prop->tp_len += (prop->tp_col - 1 - col) + added;
|
|
prop->tp_col = col + 1;
|
|
if (prop->tp_len <= 0)
|
|
{
|
|
prop->tp_len = 0;
|
|
res.can_drop = droppable;
|
|
}
|
|
}
|
|
else
|
|
prop->tp_col += added;
|
|
}
|
|
else if (prop->tp_len > 0 && prop->tp_col + prop->tp_len > col
|
|
&& prop->tp_id >= 0) // don't change length for virtual text
|
|
{
|
|
int after = col - added - (prop->tp_col - 1 + prop->tp_len);
|
|
|
|
prop->tp_len += after > 0 ? added + after : added;
|
|
res.can_drop = prop->tp_len <= 0 && droppable;
|
|
}
|
|
else
|
|
res.dirty = FALSE;
|
|
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
* Adjust the columns of text properties in line "lnum" after position "col" to
|
|
* shift by "bytes_added" (can be negative).
|
|
* Note that "col" is zero-based, while tp_col is one-based.
|
|
* Only for the current buffer.
|
|
* "flags" can have:
|
|
* APC_SAVE_FOR_UNDO: Call u_savesub() before making changes to the line.
|
|
* APC_SUBSTITUTE: Text is replaced, not inserted.
|
|
* APC_INDENT: Text is inserted before virtual text prop
|
|
* Caller is expected to check b_has_textprop and "bytes_added" being non-zero.
|
|
* Returns TRUE when props were changed.
|
|
*/
|
|
int
|
|
adjust_prop_columns(
|
|
linenr_T lnum,
|
|
colnr_T col,
|
|
int bytes_added,
|
|
int flags)
|
|
{
|
|
int proplen;
|
|
char_u *props;
|
|
int dirty = FALSE;
|
|
int ri, wi;
|
|
size_t textlen;
|
|
|
|
if (text_prop_frozen > 0)
|
|
return FALSE;
|
|
|
|
proplen = get_text_props(curbuf, lnum, &props, TRUE);
|
|
if (proplen == 0)
|
|
return FALSE;
|
|
textlen = curbuf->b_ml.ml_line_len - proplen * sizeof(textprop_T);
|
|
|
|
wi = 0; // write index
|
|
for (ri = 0; ri < proplen; ++ri)
|
|
{
|
|
textprop_T prop;
|
|
adjustres_T res;
|
|
|
|
mch_memmove(&prop, props + ri * sizeof(prop), sizeof(prop));
|
|
res = adjust_prop(&prop, col, bytes_added, flags);
|
|
if (res.dirty)
|
|
{
|
|
// Save for undo if requested and not done yet.
|
|
if ((flags & APC_SAVE_FOR_UNDO) && !dirty
|
|
&& u_savesub(lnum) == FAIL)
|
|
return FALSE;
|
|
dirty = TRUE;
|
|
|
|
// u_savesub() may have updated curbuf->b_ml, fetch it again
|
|
if (curbuf->b_ml.ml_line_lnum != lnum)
|
|
proplen = get_text_props(curbuf, lnum, &props, TRUE);
|
|
}
|
|
if (res.can_drop)
|
|
continue; // Drop this text property
|
|
mch_memmove(props + wi * sizeof(textprop_T), &prop, sizeof(textprop_T));
|
|
++wi;
|
|
}
|
|
if (dirty)
|
|
{
|
|
colnr_T newlen = (int)textlen + wi * (colnr_T)sizeof(textprop_T);
|
|
|
|
if ((curbuf->b_ml.ml_flags & ML_LINE_DIRTY) == 0)
|
|
{
|
|
char_u *p = vim_memsave(curbuf->b_ml.ml_line_ptr, newlen);
|
|
|
|
if (curbuf->b_ml.ml_flags & ML_ALLOCATED)
|
|
vim_free(curbuf->b_ml.ml_line_ptr);
|
|
curbuf->b_ml.ml_line_ptr = p;
|
|
}
|
|
curbuf->b_ml.ml_flags |= ML_LINE_DIRTY;
|
|
curbuf->b_ml.ml_line_len = newlen;
|
|
}
|
|
return dirty;
|
|
}
|
|
|
|
/*
|
|
* Adjust text properties for a line that was split in two.
|
|
* "lnum_props" is the line that has the properties from before the split.
|
|
* "lnum_top" is the top line.
|
|
* "kept" is the number of bytes kept in the first line, while
|
|
* "deleted" is the number of bytes deleted.
|
|
* "at_eol" is true if the split is after the end of the line.
|
|
*/
|
|
void
|
|
adjust_props_for_split(
|
|
linenr_T lnum_props,
|
|
linenr_T lnum_top,
|
|
int kept,
|
|
int deleted,
|
|
int at_eol)
|
|
{
|
|
char_u *props;
|
|
int count;
|
|
garray_T prevprop;
|
|
garray_T nextprop;
|
|
int i;
|
|
int skipped = kept + deleted;
|
|
|
|
if (!curbuf->b_has_textprop)
|
|
return;
|
|
|
|
// Get the text properties from "lnum_props".
|
|
count = get_text_props(curbuf, lnum_props, &props, FALSE);
|
|
ga_init2(&prevprop, sizeof(textprop_T), 10);
|
|
ga_init2(&nextprop, sizeof(textprop_T), 10);
|
|
|
|
// Keep the relevant ones in the first line, reducing the length if needed.
|
|
// Copy the ones that include the split to the second line.
|
|
// Move the ones after the split to the second line.
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
textprop_T prop;
|
|
proptype_T *pt;
|
|
int start_incl, end_incl;
|
|
int cont_prev, cont_next;
|
|
int prop_col;
|
|
|
|
// copy the prop to an aligned structure
|
|
mch_memmove(&prop, props + i * sizeof(textprop_T), sizeof(textprop_T));
|
|
|
|
pt = text_prop_type_by_id(curbuf, prop.tp_type);
|
|
start_incl = (pt != NULL && (pt->pt_flags & PT_FLAG_INS_START_INCL));
|
|
end_incl = (pt != NULL && (pt->pt_flags & PT_FLAG_INS_END_INCL));
|
|
|
|
// a text prop "above" behaves like it is on the first text column
|
|
prop_col = (prop.tp_flags & TP_FLAG_ALIGN_ABOVE) ? 1 : prop.tp_col;
|
|
|
|
if (prop_col == MAXCOL)
|
|
{
|
|
cont_prev = at_eol;
|
|
cont_next = !at_eol;
|
|
}
|
|
else
|
|
{
|
|
cont_prev = prop_col + !start_incl <= kept;
|
|
cont_next = skipped <= prop_col + prop.tp_len - !end_incl;
|
|
}
|
|
// when a prop has text it is never copied
|
|
if (prop.tp_id < 0 && cont_next)
|
|
cont_prev = FALSE;
|
|
|
|
if (cont_prev && ga_grow(&prevprop, 1) == OK)
|
|
{
|
|
textprop_T *p = ((textprop_T *)prevprop.ga_data) + prevprop.ga_len;
|
|
|
|
*p = prop;
|
|
++prevprop.ga_len;
|
|
if (p->tp_col != MAXCOL && p->tp_col + p->tp_len >= kept)
|
|
p->tp_len = kept - p->tp_col;
|
|
if (cont_next)
|
|
p->tp_flags |= TP_FLAG_CONT_NEXT;
|
|
}
|
|
|
|
// Only add the property to the next line if the length is bigger than
|
|
// zero.
|
|
if (cont_next && ga_grow(&nextprop, 1) == OK)
|
|
{
|
|
textprop_T *p = ((textprop_T *)nextprop.ga_data) + nextprop.ga_len;
|
|
|
|
*p = prop;
|
|
++nextprop.ga_len;
|
|
if (p->tp_col != MAXCOL)
|
|
{
|
|
if (p->tp_col > skipped)
|
|
p->tp_col -= skipped - 1;
|
|
else
|
|
{
|
|
p->tp_len -= skipped - p->tp_col;
|
|
p->tp_col = 1;
|
|
}
|
|
}
|
|
if (cont_prev)
|
|
p->tp_flags |= TP_FLAG_CONT_PREV;
|
|
}
|
|
}
|
|
|
|
set_text_props(lnum_top, prevprop.ga_data,
|
|
prevprop.ga_len * sizeof(textprop_T));
|
|
ga_clear(&prevprop);
|
|
set_text_props(lnum_top + 1, nextprop.ga_data,
|
|
nextprop.ga_len * sizeof(textprop_T));
|
|
ga_clear(&nextprop);
|
|
}
|
|
|
|
/*
|
|
* Prepend properties of joined line "lnum" to "new_props".
|
|
*/
|
|
void
|
|
prepend_joined_props(
|
|
char_u *new_props,
|
|
int propcount,
|
|
int *props_remaining,
|
|
linenr_T lnum,
|
|
int last_line,
|
|
long col,
|
|
int removed)
|
|
{
|
|
char_u *props;
|
|
int proplen = get_text_props(curbuf, lnum, &props, FALSE);
|
|
int i;
|
|
|
|
for (i = proplen; i-- > 0; )
|
|
{
|
|
textprop_T prop;
|
|
int end;
|
|
|
|
mch_memmove(&prop, props + i * sizeof(prop), sizeof(prop));
|
|
if (prop.tp_col == MAXCOL && !last_line)
|
|
continue; // drop property with text after the line
|
|
end = !(prop.tp_flags & TP_FLAG_CONT_NEXT);
|
|
|
|
adjust_prop(&prop, 0, -removed, 0); // Remove leading spaces
|
|
adjust_prop(&prop, -1, col, 0); // Make line start at its final column
|
|
|
|
if (last_line || end)
|
|
mch_memmove(new_props + --(*props_remaining) * sizeof(prop),
|
|
&prop, sizeof(prop));
|
|
else
|
|
{
|
|
int j;
|
|
int found = FALSE;
|
|
|
|
// Search for continuing prop.
|
|
for (j = *props_remaining; j < propcount; ++j)
|
|
{
|
|
textprop_T op;
|
|
|
|
mch_memmove(&op, new_props + j * sizeof(op), sizeof(op));
|
|
if ((op.tp_flags & TP_FLAG_CONT_PREV)
|
|
&& op.tp_id == prop.tp_id && op.tp_type == prop.tp_type)
|
|
{
|
|
found = TRUE;
|
|
op.tp_len += op.tp_col - prop.tp_col;
|
|
op.tp_col = prop.tp_col;
|
|
// Start/end is taken care of when deleting joined lines
|
|
op.tp_flags = prop.tp_flags;
|
|
mch_memmove(new_props + j * sizeof(op), &op, sizeof(op));
|
|
break;
|
|
}
|
|
}
|
|
if (!found)
|
|
internal_error("text property above joined line not found");
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif // FEAT_PROP_POPUP
|