Hi, On Wed, Jul 27, 2016 at 7:35 AM, LCD 47 <lcd...@gmail.com> wrote: >> >> > > >> >> > > On Mon, Jul 25, 2016 at 12:27 AM, LCD 47 <lcd...@gmail.com> wrote: >> >> > > > On 24 July 2016, Yegappan Lakshmanan <yegapp...@gmail.com> >> >> > > > wrote: >> >> > > >> I am attaching a patch to enhance the getqflist/getloclist() >> >> > > >> functions to return the title string and the >> >> > > >> setqflist()/setloclist() functions to set the title string. >> >> > > >> >> >> > > >> After this patch is incorporated, it will be easy to add the >> >> > > >> additional items (e.g. context, items, number, stack, etc.). >> >> > > >> >> >> > > >> The getqflist/setqflist functions now accept an optional >> >> > > >> dictionary parameter. The dictionary parameter specifies >> >> > > >> which items to get or set. If the {dict} argument is >> >> > > >> specified, then the getqflist function returns a dictionary. >> >> > > > >> >> > > > Why a dictionary (where values are ignored), rather than >> >> > > > a list, or a string of, say, comma-separated names? Or both? >> >> > > > >> >> > > >> >> > > This is to be consistent between the getqflist()/getloclist() >> >> > > and the setqflist()/setloclist() functions. In the setqflist() >> >> > > function, the value of a dictionary key specifies the value >> >> > > to set. In the getqflist() function, it specifies the value >> >> > > to return. For example, the following call sets the quickfix >> >> > > title: >> >> > > >> >> > > call setqflist([], 'a', {'title' : 'example'}) >> >> > > >> >> > > The following call returns the quickfix title: >> >> > > >> >> > > call getqflist({'title' : 1}) >> >> > >> >> > The arguments of setqflist() are already different from those >> >> > of getqflist(), so why does an extra argument has to be the same? >> >> > Why not something like this: >> >> > >> >> > call getqflist('title,context,nr') >> >> > or >> >> > call getqflist(['title', 'context', 'nr']) >> >> > >> >> > vs. >> >> > >> >> > call setqflist(errors, 'r', >> >> > \ { 'title': 'My preciousss', 'context': ctx, 'nr': -1 }) >> >> > >> >> > (BTW, { 'nr': -1 } could mean last). >> >> >> >> Although we can probably do a lot with a list of strings, there >> >> is a tendency for builtin-functions to use a dictionary to >> >> pass optional extra argumens through a dict. A list can only >> >> use "present" flags, a dictionary can also use values for the >> >> arguments. >> > >> > So basically you want all plugins daring enough to use the new >> > features to carry along dicts with useless values, just because some >> > of these values might become useful at some unspecified point in the >> > future? Vim can nicely deal with changing the type of an argument, >> > so why not use lists for now, and add dict arguments when and if >> > there is an actual use for those? >> > >> >> I did make the changes to use a list argument for the getqflist() >> function. Then realized that with a list, you cannot specify the >> quickfix list number (to pick a specific list in the stack). With a >> dict, you can modify a specific quickfix list in the stack. > > After pondering about this for a while, I believe the stack pointer > is the only one that needs a value in both getqflist() and setqflist(), > so you could in principle encode it as simply a number. That is, a > number in the list would refer to the stack pointer, as opposed to the > other names that would be alphabetic. But that would be even worse than > having a dict with dummy values. So yes, this is probably a good reason > for using dicts. >
An updated patch is attached. The getqflist() and setqflist() functions take a dict argument which specifies the things to get or set. - Yegappan -- -- You received this message from the "vim_dev" maillist. Do not top-post! Type your reply below the text you are replying to. For more information, visit http://www.vim.org/maillist.php --- You received this message because you are subscribed to the Google Groups "vim_dev" group. To unsubscribe from this group and stop receiving emails from it, send an email to vim_dev+unsubscr...@googlegroups.com. For more options, visit https://groups.google.com/d/optout.
diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt index 7b421aa..38fde85 100644 --- a/runtime/doc/eval.txt +++ b/runtime/doc/eval.txt @@ -2079,11 +2079,11 @@ getftime({fname}) Number last modification time of file getftype({fname}) String description of type of file {fname} getline({lnum}) String line {lnum} of current buffer getline({lnum}, {end}) List lines {lnum} to {end} of current buffer -getloclist({nr}) List list of location list items +getloclist({nr}[, {what}]) List list of location list items getmatches() List list of current matches getpid() Number process ID of Vim getpos({expr}) List position of cursor, mark, etc. -getqflist() List list of quickfix items +getqflist([{what}]) List list of quickfix items getreg([{regname} [, 1 [, {list}]]]) String or List contents of register getregtype([{regname}]) String type of register @@ -2238,11 +2238,12 @@ setcharsearch({dict}) Dict set character search from {dict} setcmdpos({pos}) Number set cursor position in command-line setfperm({fname}, {mode}) Number set {fname} file permissions to {mode} setline({lnum}, {line}) Number set line {lnum} to {line} -setloclist({nr}, {list}[, {action}]) +setloclist({nr}, {list}[, {action}[, {what}]]) Number modify location list using {list} setmatches({list}) Number restore a list of matches setpos({expr}, {list}) Number set the {expr} position to {list} -setqflist({list}[, {action}]) Number modify quickfix list using {list} +setqflist({list}[, {action}[, {what}]]) + Number modify quickfix list using {list} setreg({n}, {v}[, {opt}]) Number set register to value and type settabvar({nr}, {varname}, {val}) none set {varname} in tab page {nr} to {val} settabwinvar({tabnr}, {winnr}, {varname}, {val}) @@ -4275,7 +4276,7 @@ getline({lnum} [, {end}]) < To get lines from another buffer see |getbufline()| -getloclist({nr}) *getloclist()* +getloclist({nr},[, {what}]) *getloclist()* Returns a list with all the entries in the location list for window {nr}. {nr} can be the window number or the window ID. When {nr} is zero the current window is used. @@ -4284,6 +4285,10 @@ getloclist({nr}) *getloclist()* returned. For an invalid window number {nr}, an empty list is returned. Otherwise, same as |getqflist()|. + If the optional {what} dictionary argument is supplied, then + returns the items listed in {what} as a dictionary. Refer to + |getqflist()| for the supported items in {what}. + getmatches() *getmatches()* Returns a |List| with all matches previously defined by |matchadd()| and the |:match| commands. |getmatches()| is @@ -4334,7 +4339,7 @@ getpos({expr}) Get the position for {expr}. For possible values of {expr} < Also see |getcurpos()| and |setpos()|. -getqflist() *getqflist()* +getqflist([{what}]) *getqflist()* Returns a list with all the current quickfix errors. Each list item is a dictionary with these entries: bufnr number of buffer that has the file name, use @@ -4360,6 +4365,29 @@ getqflist() *getqflist()* : echo bufname(d.bufnr) ':' d.lnum '=' d.text :endfor + If the optional {what} dictionary argument is supplied, then + returns only the items listed in {what} as a dictionary. The + following string items are supported in {what}: + nr get the specified list information + title get list title + winid get window id (if opened) + all all of the above quickfix properties + + If {nr} is supplied, then the specified quickfix list + properties are returned. Otherwise the current quickfix list is + used. Non string items in {what} are ignored. The returned + dictionary contains the following entries: + nr quickfix list number + title quickfix list title text + winid quickfix window id (if opened) + + In case of error processing {what}, an empty dictionary is + returned. + + Example:> + :echo getqflist({'all':1}) + :echo getqflist({'nr':2, 'title':1}) +< getreg([{regname} [, 1 [, {list}]]]) *getreg()* The result is a String, which is the contents of register @@ -6496,7 +6524,7 @@ setline({lnum}, {text}) *setline()* :endfor < Note: The '[ and '] marks are not set. -setloclist({nr}, {list} [, {action}]) *setloclist()* +setloclist({nr}, {list} [, {action}[, {what}]) *setloclist()* Create or replace or add to the location list for window {nr}. {nr} can be the window number or the window ID. When {nr} is zero the current window is used. @@ -6506,6 +6534,10 @@ setloclist({nr}, {list} [, {action}]) *setloclist()* Otherwise, same as |setqflist()|. Also see |location-list|. + If the optional {what} dictionary argument is supplied, then + only the items listed in {what} are set. Refer to |setqflist()| + for the list of supported keys in {what}. + setmatches({list}) *setmatches()* Restores a list of matches saved by |getmatches()|. Returns 0 if successful, otherwise -1. All current matches are cleared @@ -6558,8 +6590,7 @@ setpos({expr}, {list}) also set the preferred column. Also see the "curswant" key in |winrestview()|. - -setqflist({list} [, {action}]) *setqflist()* +setqflist({list} [, {action}[, {what}]]) *setqflist()* Create or replace or add to the quickfix list using the items in {list}. Each item in {list} is a dictionary. Non-dictionary items in {list} are ignored. Each dictionary @@ -6604,6 +6635,18 @@ setqflist({list} [, {action}]) *setqflist()* If {action} is not present or is set to ' ', then a new list is created. + If the optional {what} dictionary argument is supplied, then + only the items listed in {what} are set. The first {list} + argument is ignored. The following items can be specified in + {what}: + nr list number in the quickfix stack + title quickfix list title text + + If the 'nr' item is not present, then the current quickfix list + is modified. Unsupported keys in {what} are ignored. Example: + :call setqflist([], 'r', {'title':'My search'}) + :call setqflist([], 'r', {'nr':2, 'title':'Errors'}) +< Returns zero for success, -1 for failure. This function can be used to create a quickfix list diff --git a/src/evalfunc.c b/src/evalfunc.c index ae17038..8eee867 100644 --- a/src/evalfunc.c +++ b/src/evalfunc.c @@ -170,6 +170,7 @@ static void f_getfsize(typval_T *argvars, typval_T *rettv); static void f_getftime(typval_T *argvars, typval_T *rettv); static void f_getftype(typval_T *argvars, typval_T *rettv); static void f_getline(typval_T *argvars, typval_T *rettv); +static void f_getloclist(typval_T *argvars UNUSED, typval_T *rettv UNUSED); static void f_getmatches(typval_T *argvars, typval_T *rettv); static void f_getpid(typval_T *argvars, typval_T *rettv); static void f_getcurpos(typval_T *argvars, typval_T *rettv); @@ -586,11 +587,11 @@ static struct fst {"getftime", 1, 1, f_getftime}, {"getftype", 1, 1, f_getftype}, {"getline", 1, 2, f_getline}, - {"getloclist", 1, 1, f_getqflist}, + {"getloclist", 1, 2, f_getloclist}, {"getmatches", 0, 0, f_getmatches}, {"getpid", 0, 0, f_getpid}, {"getpos", 1, 1, f_getpos}, - {"getqflist", 0, 0, f_getqflist}, + {"getqflist", 0, 1, f_getqflist}, {"getreg", 0, 3, f_getreg}, {"getregtype", 0, 1, f_getregtype}, {"gettabvar", 2, 3, f_gettabvar}, @@ -736,10 +737,10 @@ static struct fst {"setcmdpos", 1, 1, f_setcmdpos}, {"setfperm", 2, 2, f_setfperm}, {"setline", 2, 2, f_setline}, - {"setloclist", 2, 3, f_setloclist}, + {"setloclist", 2, 4, f_setloclist}, {"setmatches", 1, 1, f_setmatches}, {"setpos", 2, 2, f_setpos}, - {"setqflist", 1, 2, f_setqflist}, + {"setqflist", 1, 3, f_setqflist}, {"setreg", 2, 3, f_setreg}, {"settabvar", 3, 3, f_settabvar}, {"settabwinvar", 4, 4, f_settabwinvar}, @@ -4459,6 +4460,50 @@ f_getline(typval_T *argvars, typval_T *rettv) get_buffer_lines(curbuf, lnum, end, retlist, rettv); } +static void get_qf_loc_list(int is_qf, win_T *wp, typval_T *what_arg, typval_T *rettv); + + static void +get_qf_loc_list(int is_qf, win_T *wp, typval_T *what_arg, typval_T *rettv) +{ +#ifdef FEAT_QUICKFIX + if (what_arg->v_type == VAR_UNKNOWN) + { + if (rettv_list_alloc(rettv) == OK) + if (is_qf || (wp != NULL)) + (void)get_errorlist(wp, -1, rettv->vval.v_list); + } + else + { + if (rettv_dict_alloc(rettv) == OK) + if (is_qf || (wp != NULL)) + { + if (what_arg->v_type == VAR_DICT) + { + dict_T *d = what_arg->vval.v_dict; + if (d != NULL) + get_errorlist_properties(wp, d, rettv->vval.v_dict); + } + else + EMSG(_(e_dictreq)); + } + } +#endif +} + +/* + * "getloclist()" function + */ + static void +f_getloclist(typval_T *argvars UNUSED, typval_T *rettv UNUSED) +{ +#ifdef FEAT_QUICKFIX + win_T *wp; + + wp = find_win_by_nr(&argvars[0], NULL); + get_qf_loc_list(FALSE, wp, &argvars[1], rettv); +#endif +} + /* * "getmatches()" function */ @@ -4596,28 +4641,13 @@ f_getpos(typval_T *argvars, typval_T *rettv) } /* - * "getqflist()" and "getloclist()" functions + * "getqflist()" function */ static void f_getqflist(typval_T *argvars UNUSED, typval_T *rettv UNUSED) { #ifdef FEAT_QUICKFIX - win_T *wp; -#endif - -#ifdef FEAT_QUICKFIX - if (rettv_list_alloc(rettv) == OK) - { - wp = NULL; - if (argvars[0].v_type != VAR_UNKNOWN) /* getloclist() */ - { - wp = find_win_by_nr(&argvars[0], NULL); - if (wp == NULL) - return; - } - - (void)get_errorlist(wp, rettv->vval.v_list); - } + get_qf_loc_list(TRUE, NULL, &argvars[0], rettv); #endif } @@ -9454,7 +9484,7 @@ f_setline(typval_T *argvars, typval_T *rettv) appended_lines_mark(lcount, added); } -static void set_qf_ll_list(win_T *wp, typval_T *list_arg, typval_T *action_arg, typval_T *rettv); +static void set_qf_ll_list(win_T *wp, typval_T *list_arg, typval_T *action_arg, typval_T *what_arg, typval_T *rettv); /* * Used by "setqflist()" and "setloclist()" functions @@ -9464,6 +9494,7 @@ set_qf_ll_list( win_T *wp UNUSED, typval_T *list_arg UNUSED, typval_T *action_arg UNUSED, + typval_T *what_arg UNUSED, typval_T *rettv) { #ifdef FEAT_QUICKFIX @@ -9480,6 +9511,8 @@ set_qf_ll_list( else { list_T *l = list_arg->vval.v_list; + dict_T *d = NULL; + int valid_dict = TRUE; if (action_arg->v_type == VAR_STRING) { @@ -9496,8 +9529,20 @@ set_qf_ll_list( else EMSG(_(e_stringreq)); - if (l != NULL && action && set_errorlist(wp, l, action, - (char_u *)(wp == NULL ? "setqflist()" : "setloclist()")) == OK) + if (action_arg->v_type != VAR_UNKNOWN && + what_arg->v_type != VAR_UNKNOWN) + { + if (what_arg->v_type == VAR_DICT) + d = what_arg->vval.v_dict; + else + { + EMSG(_(e_dictreq)); + valid_dict = FALSE; + } + } + + if (l != NULL && action && valid_dict && set_errorlist(wp, l, action, + (char_u *)(wp == NULL ? "setqflist()" : "setloclist()"), d) == OK) rettv->vval.v_number = 0; } #endif @@ -9515,7 +9560,7 @@ f_setloclist(typval_T *argvars, typval_T *rettv) win = find_win_by_nr(&argvars[0], NULL); if (win != NULL) - set_qf_ll_list(win, &argvars[1], &argvars[2], rettv); + set_qf_ll_list(win, &argvars[1], &argvars[2], &argvars[3], rettv); } /* @@ -9681,7 +9726,7 @@ f_setpos(typval_T *argvars, typval_T *rettv) static void f_setqflist(typval_T *argvars, typval_T *rettv) { - set_qf_ll_list(NULL, &argvars[0], &argvars[1], rettv); + set_qf_ll_list(NULL, &argvars[0], &argvars[1], &argvars[2], rettv); } /* diff --git a/src/proto/quickfix.pro b/src/proto/quickfix.pro index 02c2d98..99f5ede 100644 --- a/src/proto/quickfix.pro +++ b/src/proto/quickfix.pro @@ -27,8 +27,9 @@ void ex_cnext(exarg_T *eap); void ex_cfile(exarg_T *eap); void ex_vimgrep(exarg_T *eap); char_u *skip_vimgrep_pat(char_u *p, char_u **s, int *flags); -int get_errorlist(win_T *wp, list_T *list); -int set_errorlist(win_T *wp, list_T *list, int action, char_u *title); +int get_errorlist_properties(win_T *wp, dict_T *what, dict_T *retdict); +int get_errorlist(win_T *wp, int qf_idx, list_T *list); +int set_errorlist(win_T *wp, list_T *list, int action, char_u *title, dict_T *what); void ex_cbuffer(exarg_T *eap); void ex_cexpr(exarg_T *eap); void ex_helpgrep(exarg_T *eap); diff --git a/src/quickfix.c b/src/quickfix.c index b607170..e653898 100644 --- a/src/quickfix.c +++ b/src/quickfix.c @@ -3151,6 +3151,24 @@ qf_find_buf(qf_info_T *qi) } /* + * Update the w:quickfix_title variable in the quickfix/location list window + */ + static void +qf_update_win_titlevar(qf_info_T *qi) +{ + win_T *win; + win_T *curwin_save; + + if ((win = qf_find_win(qi)) != NULL) + { + curwin_save = curwin; + curwin = win; + qf_set_title_var(qi); + curwin = curwin_save; + } +} + +/* * Find the quickfix buffer. If it exists, update the contents. */ static void @@ -3158,7 +3176,6 @@ qf_update_buffer(qf_info_T *qi, qfline_T *old_last) { buf_T *buf; win_T *win; - win_T *curwin_save; aco_save_T aco; /* Check if a buffer for the quickfix list exists. Update it. */ @@ -3171,13 +3188,7 @@ qf_update_buffer(qf_info_T *qi, qfline_T *old_last) /* set curwin/curbuf to buf and save a few things */ aucmd_prepbuf(&aco, buf); - if ((win = qf_find_win(qi)) != NULL) - { - curwin_save = curwin; - curwin = win; - qf_set_title_var(qi); - curwin = curwin_save; - } + qf_update_win_titlevar(qi); qf_fill_buffer(qi, buf, old_last); @@ -4542,9 +4553,10 @@ unload_dummy_buffer(buf_T *buf, char_u *dirname_start) #if defined(FEAT_EVAL) || defined(PROTO) /* * Add each quickfix error to list "list" as a dictionary. + * If qf_idx is -1, use the current list. Otherwise, use the specified list. */ int -get_errorlist(win_T *wp, list_T *list) +get_errorlist(win_T *wp, int qf_idx, list_T *list) { qf_info_T *qi = &ql_info; dict_T *dict; @@ -4560,12 +4572,15 @@ get_errorlist(win_T *wp, list_T *list) return FAIL; } - if (qi->qf_curlist >= qi->qf_listcount - || qi->qf_lists[qi->qf_curlist].qf_count == 0) + if (qf_idx == -1) + qf_idx = qi->qf_curlist; + + if (qf_idx >= qi->qf_listcount + || qi->qf_lists[qf_idx].qf_count == 0) return FAIL; - qfp = qi->qf_lists[qi->qf_curlist].qf_start; - for (i = 1; !got_int && i <= qi->qf_lists[qi->qf_curlist].qf_count; ++i) + qfp = qi->qf_lists[qf_idx].qf_start; + for (i = 1; !got_int && i <= qi->qf_lists[qf_idx].qf_count; ++i) { /* Handle entries with a non-existing buffer number. */ bufnum = qfp->qf_fnum; @@ -4600,16 +4615,93 @@ get_errorlist(win_T *wp, list_T *list) } /* - * Populate the quickfix list with the items supplied in the list - * of dictionaries. "title" will be copied to w:quickfix_title. - * "action" is 'a' for add, 'r' for replace. Otherwise create a new list. + * Flags used by getqflist()/getloclist() to determine which fields to return. + */ +enum { + QF_GETLIST_NONE = 0x0, + QF_GETLIST_TITLE = 0x1, + QF_GETLIST_ITEMS = 0x2, + QF_GETLIST_NR = 0x4, + QF_GETLIST_WINID = 0x8, + QF_GETLIST_ALL = 0xFF +}; + +/* + * Return quickfix/location list details (title) as a + * dictionary. 'what' contains the details to return. If 'list_idx' is -1, + * then current list is used. Otherwise the specified list is used. */ int -set_errorlist( - win_T *wp, - list_T *list, - int action, - char_u *title) +get_errorlist_properties(win_T *wp, dict_T *what, dict_T *retdict) +{ + qf_info_T *qi = &ql_info; + int status = FAIL; + int qf_idx; + dictitem_T *di; + int flags = QF_GETLIST_NONE; + + if (wp != NULL) + { + qi = GET_LOC_LIST(wp); + if (qi == NULL) + return FAIL; + } + + qf_idx = qi->qf_curlist; /* default is the current list */ + if ((di = dict_find(what, (char_u *)"nr", -1)) != NULL) + { + /* Use the specified quickfix/location list */ + if (di->di_tv.v_type == VAR_NUMBER) + { + qf_idx = di->di_tv.vval.v_number; + if (qf_idx < 0 || qf_idx >= qi->qf_listcount) + return FAIL; + flags |= QF_GETLIST_NR; + } + else + return FAIL; + } + + if (dict_find(what, (char_u *)"all", -1) != NULL) + flags |= QF_GETLIST_ALL; + + if (dict_find(what, (char_u *)"title", -1) != NULL) + flags |= QF_GETLIST_TITLE; + + if (dict_find(what, (char_u *)"winid", -1) != NULL) + flags |= QF_GETLIST_WINID; + + if (flags & QF_GETLIST_TITLE) + { + char_u *t; + t = qi->qf_lists[qf_idx].qf_title; + if (t == NULL) + t = (char_u *)""; + status = dict_add_nr_str(retdict, "title", 0L, t); + } + if ((status == OK) && (flags & QF_GETLIST_NR)) + status = dict_add_nr_str(retdict, "nr", qf_idx, NULL); + if ((status == OK) && (flags & QF_GETLIST_WINID)) + { + win_T *win; + win = qf_find_win(qi); + if (win != NULL) + status = dict_add_nr_str(retdict, "winid", win->w_id, NULL); + } + + return status; +} + +/* + * Add list of entries to quickfix/location list. Each list entry is + * a dictionary with item information. + */ + static int +qf_add_entries( + qf_info_T *qi, + list_T *list, + char_u *title, + int action) { listitem_T *li; dict_T *d; @@ -4623,16 +4715,8 @@ set_errorlist( #endif int valid, status; int retval = OK; - qf_info_T *qi = &ql_info; int did_bufnr_emsg = FALSE; - if (wp != NULL) - { - qi = ll_get_or_alloc_list(wp); - if (qi == NULL) - return FAIL; - } - if (action == ' ' || qi->qf_curlist == qi->qf_listcount) /* make place for a new list */ qf_new_list(qi, title); @@ -4729,6 +4813,74 @@ set_errorlist( return retval; } + + static int +qf_set_properties(qf_info_T *qi, dict_T *what, int action) +{ + dictitem_T *di; + int retval = FAIL; + int qf_idx; + + qf_idx = qi->qf_curlist; /* default is the current list */ + if ((di = dict_find(what, (char_u *)"nr", -1)) != NULL) + { + /* Use the specified quickfix/location list */ + if (di->di_tv.v_type == VAR_NUMBER) + { + qf_idx = di->di_tv.vval.v_number; + if (qf_idx < 0 || qf_idx >= qi->qf_listcount) + return FAIL; + } + else + return FAIL; + } + + if ((di = dict_find(what, (char_u *)"title", -1)) != NULL) + { + if (di->di_tv.v_type == VAR_STRING) + { + vim_free(qi->qf_lists[qf_idx].qf_title); + qi->qf_lists[qf_idx].qf_title = + get_dict_string(what, (char_u *)"title", TRUE); + if (qf_idx == qi->qf_curlist) + qf_update_win_titlevar(qi); + retval = OK; + } + } + + return retval; +} + +/* + * Populate the quickfix list with the items supplied in the list + * of dictionaries. "title" will be copied to w:quickfix_title. + * "action" is 'a' for add, 'r' for replace. Otherwise create a new list. + */ + int +set_errorlist( + win_T *wp, + list_T *list, + int action, + char_u *title, + dict_T *what) +{ + qf_info_T *qi = &ql_info; + int retval = OK; + + if (wp != NULL) + { + qi = ll_get_or_alloc_list(wp); + if (qi == NULL) + return FAIL; + } + + if (what != NULL) + retval = qf_set_properties(qi, what, action); + else + retval = qf_add_entries(qi, list, title, action); + + return retval; +} #endif /* diff --git a/src/tag.c b/src/tag.c index cfc2b51..e388a43 100644 --- a/src/tag.c +++ b/src/tag.c @@ -916,7 +916,7 @@ do_tag( } vim_snprintf((char *)IObuff, IOSIZE, "ltag %s", tag); - set_errorlist(curwin, list, ' ', IObuff); + set_errorlist(curwin, list, ' ', IObuff, NULL); list_free(list); vim_free(fname); diff --git a/src/testdir/test_quickfix.vim b/src/testdir/test_quickfix.vim index e79315b..231565a 100644 --- a/src/testdir/test_quickfix.vim +++ b/src/testdir/test_quickfix.vim @@ -1504,3 +1504,42 @@ func Test_duplicate_buf() call delete('Xgrepthis') endfunc + +" Quickfix/Location list set/get properties tests +function Xproperty_tests(cchar) + call s:setup_commands(a:cchar) + + " Error cases + call assert_fails('call g:Xgetlist(99)', 'E715:') + call assert_fails('call g:Xsetlist(99)', 'E714:') + call assert_fails('call g:Xsetlist([], "a", [])', 'E715:') + + " Set and get the title + Xopen + wincmd p + call g:Xsetlist([{'filename':'foo', 'lnum':27}]) + call g:Xsetlist([], 'a', {'title' : 'Sample'}) + let d = g:Xgetlist({"title":1}) + call assert_equal('Sample', d.title) + + Xopen + call assert_equal('Sample', w:quickfix_title) + Xclose + + " Invalid arguments + call assert_fails('call g:Xgetlist([])', 'E715') + call assert_fails('call g:Xsetlist([], "a", [])', 'E715') + let s = g:Xsetlist([], 'a', {'abc':1}) + call assert_equal(-1, s) + + call assert_equal({}, g:Xgetlist({'abc':1})) + + if a:cchar == 'l' + call assert_equal({}, getloclist(99, ['title'])) + endif +endfunction + +function Test_qf_property() + call Xproperty_tests('c') + call Xproperty_tests('l') +endfunction