vim: src/quickfix.c comparison

comparison src/quickfix.c @ 16050:c19853508d3e v8.1.1030

patch 8.1.1030: quickfix function arguments are inconsistent commit https://github.com/vim/vim/commit/0398e00a1bf79e85223fb26938c8dd0d54883b77 Author: Bram Moolenaar <Bram@vim.org> Date: Thu Mar 21 21:12:49 2019 +0100 patch 8.1.1030: quickfix function arguments are inconsistent Problem: Quickfix function arguments are inconsistent. Solution: Pass a list pointer instead of info and index. (Yegappan Lakshmanan, closes #4135)

author	Bram Moolenaar <Bram@vim.org>
date	Thu, 21 Mar 2019 21:15:06 +0100
parents	096b8ccd855e
children	d1efe0dbe6b0

comparison

equal deleted inserted replaced

-:75c99104f6b5
+:c19853508d3e
 static int	quickfix_busy = 0;
 static efm_T	*fmt_start = NULL; // cached across qf_parse_line() calls
 static void	qf_new_list(qf_info_T *qi, char_u *qf_title);
-static int	qf_add_entry(qf_info_T *qi, int qf_idx, char_u *dir, char_u *fname, char_u *module, int bufnum, char_u *mesg, long lnum, int col, int vis_col, char_u *pattern, int nr, int type, int valid);
+static int	qf_add_entry(qf_list_T *qfl, char_u *dir, char_u *fname, char_u *module, int bufnum, char_u *mesg, long lnum, int col, int vis_col, char_u *pattern, int nr, int type, int valid);
 static void	qf_free(qf_list_T *qfl);
 static char_u	*qf_types(int, int);
-static int	qf_get_fnum(qf_info_T *qi, int qf_idx, char_u *, char_u *);
+static int	qf_get_fnum(qf_list_T *qfl, char_u *, char_u *);
 static char_u	*qf_push_dir(char_u *, struct dir_stack_T **, int is_file_stack);
 static char_u	*qf_pop_dir(struct dir_stack_T **);
 static char_u	*qf_guess_filepath(qf_list_T *qfl, char_u *);
 static void	qf_fmt_text(char_u *text, char_u *buf, int bufsize);
 static int	qf_win_pos_update(qf_info_T *qi, int old_qf_index);
 /*
 * Parse multi-line error format prefixes (%C and %Z)
 */
 static int
 qf_parse_multiline_pfx(
-	qf_info_T *qi,
-	int qf_idx,
 	int idx,
 	qf_list_T *qfl,
 	qffields_T *fields)
 {
 char_u		*ptr;
 	    qfprev->qf_lnum = fields->lnum;
 	if (!qfprev->qf_col)
 	    qfprev->qf_col = fields->col;
 	qfprev->qf_viscol = fields->use_viscol;
 	if (!qfprev->qf_fnum)
-	    qfprev->qf_fnum = qf_get_fnum(qi, qf_idx,
+	    qfprev->qf_fnum = qf_get_fnum(qfl,
 		    qfl->qf_directory,
 		    *fields->namebuf || qfl->qf_directory != NULL
 		    ? fields->namebuf
 		    : qfl->qf_currfile != NULL && fields->valid
 		    ? qfl->qf_currfile : 0);
 * Parse a line and get the quickfix fields.
 * Return the QF_ status.
 */
 static int
 qf_parse_line(
-	qf_info_T	*qi,
+	qf_list_T	*qfl,
-	int		qf_idx,
 	char_u		*linebuf,
 	int		linelen,
 	efm_T		*fmt_first,
 	qffields_T	*fields)
 {
 efm_T		*fmt_ptr;
 int			idx = 0;
 char_u		*tail = NULL;
-qf_list_T		*qfl = &qi->qf_lists[qf_idx];
 int			status;
 restofline:
 // If there was no %> item start at the first pattern
 if (fmt_start == NULL)
 	    qfl->qf_multiline = TRUE;	// start of a multi-line message
 	    qfl->qf_multiignore = FALSE;// reset continuation
 	}
 	else if (vim_strchr((char_u *)"CZ", idx) != NULL)
 	{				// continuation of multi-line msg
-	    status = qf_parse_multiline_pfx(qi, qf_idx, idx, qfl, fields);
+	    status = qf_parse_multiline_pfx(idx, qfl, fields);
 	    if (status != QF_OK)
 		return status;
 	}
 	else if (vim_strchr((char_u *)"OPQ", idx) != NULL)
 	{				// global file names
 /*
 * Returns TRUE if the specified quickfix/location list is empty.
 */
 static int
-qf_list_empty(qf_info_T *qi, int qf_idx)
+qf_list_empty(qf_list_T *qfl)
 {
-if (qi == NULL || qf_idx < 0 || qf_idx >= LISTCOUNT)
+return qfl == NULL || qfl->qf_count <= 0;
-	return TRUE;
+}
-return qi->qf_lists[qf_idx].qf_count <= 0;
+/*
+* Return a pointer to a list in the specified quickfix stack
+*/
+static qf_list_T *
+qf_get_list(qf_info_T *qi, int idx)
+{
+return &qi->qf_lists[idx];
 }
 /*
 * Allocate the fields used for parsing lines and populating a quickfix list.
 */
 }
 else
 {
 	// Adding to existing list, use last entry.
 	adding = TRUE;
-	if (!qf_list_empty(qi, qf_idx))
+	if (!qf_list_empty(qf_get_list(qi, qf_idx)))
 	    old_last = qi->qf_lists[qf_idx].qf_last;
 }
-qfl = &qi->qf_lists[qf_idx];
+qfl = qf_get_list(qi, qf_idx);
 // Use the local value of 'errorformat' if it's set.
 if (errorformat == p_efm && tv == NULL && *buf->b_p_efm != NUL)
 	efm = buf->b_p_efm;
 else
 	if (status == QF_NOMEM)		// memory alloc failure
 	    goto qf_init_end;
 	if (status == QF_END_OF_INPUT)	// end of input
 	    break;
-	status = qf_parse_line(qi, qf_idx, state.linebuf, state.linelen,
+	status = qf_parse_line(qfl, state.linebuf, state.linelen,
 							fmt_first, &fields);
 	if (status == QF_FAIL)
 	    goto error2;
 	if (status == QF_NOMEM)
 	    goto qf_init_end;
 	if (status == QF_IGNORE_LINE)
 	    continue;
-	if (qf_add_entry(qi,
+	if (qf_add_entry(qfl,
-			qf_idx,
 			qfl->qf_directory,
 			(*fields.namebuf || qfl->qf_directory != NULL)
 			    ? fields.namebuf
 			    : ((qfl->qf_currfile != NULL && fields.valid)
 				? qfl->qf_currfile : (char_u *)NULL),
 * Return a pointer to the current list in the specified quickfix stack
 */
 static qf_list_T *
 qf_get_curlist(qf_info_T *qi)
 {
-return &qi->qf_lists[qi->qf_curlist];
+return qf_get_list(qi, qi->qf_curlist);
 }
 /*
 * Prepare for adding a new quickfix list. If the current list is in the
 * middle of the stack, then all the following lists are freed and then
 	// No references to this location list.
 	// If the quickfix window buffer is loaded, then wipe it
 	wipe_qf_buffer(qi);
 	for (i = 0; i < qi->qf_listcount; ++i)
-	    qf_free(&qi->qf_lists[i]);
+	    qf_free(qf_get_list(qi, i));
 	vim_free(qi);
 }
 }
 /*
 	ll_free_all(&wp->w_llist_ref);
 }
 else
 	// quickfix list
 	for (i = 0; i < qi->qf_listcount; ++i)
-	    qf_free(&qi->qf_lists[i]);
+	    qf_free(qf_get_list(qi, i));
 }
 /*
 * Delay freeing of location list stacks when the quickfix code is running.
 * Used to avoid problems with autocmds freeing location list stacks when the
 * Add an entry to the end of the list of errors.
 * Returns OK or FAIL.
 */
 static int
 qf_add_entry(
-qf_info_T	*qi,		// quickfix list
+qf_list_T	*qfl,		// quickfix list entry
-int		qf_idx,		// list index
 char_u	*dir,		// optional directory name
 char_u	*fname,		// file name or NULL
 char_u	*module,	// module name or NULL
 int		bufnum,		// buffer number or zero
 char_u	*mesg,		// message
 char_u	*pattern,	// search pattern
 int		nr,		// error number
 int		type,		// type character
 int		valid)		// valid entry
 {
-qf_list_T	*qfl = &qi->qf_lists[qf_idx];
 qfline_T	*qfp;
 qfline_T	**lastp;	// pointer to qf_last or NULL
 if ((qfp = (qfline_T *)alloc((unsigned)sizeof(qfline_T))) == NULL)
 	return FAIL;
 	if (buf != NULL)
 	    buf->b_has_qf_entry |=
 		IS_QF_LIST(qfl) ? BUF_HAS_QF_ENTRY : BUF_HAS_LL_ENTRY;
 }
 else
-	qfp->qf_fnum = qf_get_fnum(qi, qf_idx, dir, fname);
+	qfp->qf_fnum = qf_get_fnum(qfl, dir, fname);
 if ((qfp->qf_text = vim_strsave(mesg)) == NULL)
 {
 	vim_free(qfp);
 	return FAIL;
 }
 	type = 0;
 qfp->qf_type = type;
 qfp->qf_valid = valid;
 lastp = &qfl->qf_last;
-if (qf_list_empty(qi, qf_idx))	// first element in the list
+if (qf_list_empty(qfl))		// first element in the list
 {
 	qfl->qf_start = qfp;
 	qfl->qf_ptr = qfp;
 	qfl->qf_index = 0;
 	qfp->qf_prev = NULL;
 /*
 * Copy location list entries from 'from_qfl' to 'to_qfl'.
 */
 static int
-copy_loclist_entries(qf_list_T *from_qfl, qf_list_T *to_qfl, qf_info_T *to_qi)
+copy_loclist_entries(qf_list_T *from_qfl, qf_list_T *to_qfl)
 {
 int		i;
 qfline_T    *from_qfp;
 qfline_T    *prevp;
 // copy all the location entries in this list
 for (i = 0, from_qfp = from_qfl->qf_start;
 	    i < from_qfl->qf_count && from_qfp != NULL;
 	    ++i, from_qfp = from_qfp->qf_next)
 {
-	if (qf_add_entry(to_qi,
+	if (qf_add_entry(to_qfl,
-		    to_qi->qf_curlist,
 		    NULL,
 		    NULL,
 		    from_qfp->qf_module,
 		    0,
 		    from_qfp->qf_text,
 /*
 * Copy the specified location list 'from_qfl' to 'to_qfl'.
 */
 static int
-copy_loclist(qf_list_T *from_qfl, qf_list_T *to_qfl, qf_info_T *to_qi)
+copy_loclist(qf_list_T *from_qfl, qf_list_T *to_qfl)
 {
 // Some of the fields are populated by qf_add_entry()
 to_qfl->qfl_type = from_qfl->qfl_type;
 to_qfl->qf_nonevalid = from_qfl->qf_nonevalid;
 to_qfl->qf_count = 0;
 }
 else
 	to_qfl->qf_ctx = NULL;
 if (from_qfl->qf_count)
-	if (copy_loclist_entries(from_qfl, to_qfl, to_qi) == FAIL)
+	if (copy_loclist_entries(from_qfl, to_qfl) == FAIL)
 	    return FAIL;
 to_qfl->qf_index = from_qfl->qf_index;	// current index in the list
 // Assign a new ID for the location list
 // Copy the location lists one at a time
 for (idx = 0; idx < qi->qf_listcount; ++idx)
 {
 	to->w_llist->qf_curlist = idx;
-	if (copy_loclist(&qi->qf_lists[idx],
+	if (copy_loclist(qf_get_list(qi, idx),
-			&to->w_llist->qf_lists[idx], to->w_llist) == FAIL)
+			qf_get_list(to->w_llist, idx)) == FAIL)
 	{
 	    qf_free_all(to);
 	    return;
 	}
 }
 /*
 * Get buffer number for file "directory/fname".
 * Also sets the b_has_qf_entry flag.
 */
 static int
-qf_get_fnum(qf_info_T *qi, int qf_idx, char_u *directory, char_u *fname)
+qf_get_fnum(qf_list_T *qfl, char_u *directory, char_u *fname)
 {
-qf_list_T	*qfl = &qi->qf_lists[qf_idx];
 char_u	*ptr = NULL;
 buf_T	*buf;
 char_u	*bufname;
 if (fname == NULL || *fname == NUL)		// no file name
 }
 win_goto(win);
 // If the location list for the window is not set, then set it
 // to the location list from the location window
-if (win->w_llist == NULL)
+if (win->w_llist == NULL && ll_ref != NULL)
 	win_set_loclist(win, ll_ref);
 }
 /*
 * Go to a window that contains the specified buffer 'qf_fnum'. If a window is
 int			retval = OK;
 if (qi == NULL)
 	qi = &ql_info;
-if (qf_stack_empty(qi) || qf_list_empty(qi, qi->qf_curlist))
+if (qf_stack_empty(qi) || qf_list_empty(qf_get_curlist(qi)))
 {
 	emsg(_(e_quickfix));
 	return;
 }
 	    emsg(_(e_loclist));
 	    return;
 	}
 }
-if (qf_stack_empty(qi) || qf_list_empty(qi, qi->qf_curlist))
+if (qf_stack_empty(qi) || qf_list_empty(qf_get_curlist(qi)))
 {
 	emsg(_(e_quickfix));
 	return;
 }
 if (*arg == '+')
 	    return;
 	qi = wp->w_llist;
 }
 for (idx = 0; idx < qi->qf_listcount; ++idx)
-	if (!qf_list_empty(qi, idx))
+{
-	    for (i = 0, qfp = qi->qf_lists[idx].qf_start;
+	qf_list_T	*qfl = qf_get_list(qi, idx);
-			i < qi->qf_lists[idx].qf_count && qfp != NULL;
+	if (!qf_list_empty(qfl))
+	    for (i = 0, qfp = qfl->qf_start;
+			i < qfl->qf_count && qfp != NULL;
 			++i, qfp = qfp->qf_next)
 		if (qfp->qf_fnum == curbuf->b_fnum)
 		{
 		    found_one = TRUE;
 		    if (qfp->qf_lnum >= line1 && qfp->qf_lnum <= line2)
 			    qfp->qf_lnum += amount;
 		    }
 		    else if (amount_after && qfp->qf_lnum > line2)
 			qfp->qf_lnum += amount_after;
 		}
+}
 if (!found_one)
 	curbuf->b_has_qf_entry &= ~buf_has_flag;
 }
 	return;
 if (IS_LL_WINDOW(curwin))
 	qi = GET_LOC_LIST(curwin);
-if (qf_list_empty(qi, qi->qf_curlist))
+if (qf_list_empty(qf_get_curlist(qi)))
 {
 	emsg(_(e_quickfix));
 	return;
 }
 // If a quickfix window is open but we have no errors to display,
 // close the window.  If a quickfix window is not open, then open
 // it if we have errors; otherwise, leave it closed.
 if (qf_stack_empty(qi)
 	    || qfl->qf_nonevalid
-	    || qf_list_empty(qi, qi->qf_curlist))
+	    || qf_list_empty(qf_get_curlist(qi)))
 {
 	if (win != NULL)
 	    ex_cclose(eap);
 }
 else if (win == NULL)
 {
 if (qf_restore_list(qi, save_qfid) == FAIL)
 	return;
 // Autocommands might have cleared the list, check for that.
-if (!qf_list_empty(qi, qi->qf_curlist))
+if (!qf_list_empty(qf_get_curlist(qi)))
 	qf_jump(qi, 0, 0, forceit);
 }
 /*
 * Return TRUE when using ":vimgrep" for ":grep".
 		    col, NULL, NULL) > 0)
 	{
 	    // Pass the buffer number so that it gets used even for a
 	    // dummy buffer, unless duplicate_name is set, then the
 	    // buffer will be wiped out below.
-	    if (qf_add_entry(qi,
+	    if (qf_add_entry(qf_get_curlist(qi),
-			qi->qf_curlist,
 			NULL,       // dir
 			fname,
 			NULL,
 			duplicate_name ? 0 : buf->b_fnum,
 			ml_get_buf(buf,
 	decr_quickfix_busy();
 	goto theend;
 }
 // Jump to first match.
-if (!qf_list_empty(qi, qi->qf_curlist))
+if (!qf_list_empty(qf_get_curlist(qi)))
 {
 	if ((flags & VGR_NOJUMP) == 0)
 	    vgr_jump_to_match(qi, eap->forceit, &redraw_for_dummy,
 		    first_match_buf, target_dir);
 }
 */
 int
 get_errorlist(qf_info_T *qi_arg, win_T *wp, int qf_idx, list_T *list)
 {
 qf_info_T	*qi = qi_arg;
+qf_list_T	*qfl;
 dict_T	*dict;
 char_u	buf[2];
 qfline_T	*qfp;
 int		i;
 int		bufnum;
 }
 if (qf_idx == INVALID_QFIDX)
 	qf_idx = qi->qf_curlist;
-if (qf_idx >= qi->qf_listcount || qf_list_empty(qi, qf_idx))
+if (qf_idx >= qi->qf_listcount)
 	return FAIL;
-qfp = qi->qf_lists[qf_idx].qf_start;
+qfl = qf_get_list(qi, qf_idx);
-for (i = 1; !got_int && i <= qi->qf_lists[qf_idx].qf_count; ++i)
+if (qf_list_empty(qfl))
+	return FAIL;
+qfp = qfl->qf_start;
+for (i = 1; !got_int && i <= qfl->qf_count; ++i)
 {
 	// Handle entries with a non-existing buffer number.
 	bufnum = qfp->qf_fnum;
 	if (bufnum != 0 && (buflist_findnr(bufnum) == NULL))
 	    bufnum = 0;
 /*
 * Return the current quickfix list index as 'idx' in retdict
 */
 static int
-qf_getprop_idx(qf_info_T *qi, int qf_idx, dict_T *retdict)
+qf_getprop_idx(qf_list_T *qfl, dict_T *retdict)
 {
-int curidx = qi->qf_lists[qf_idx].qf_index;
+int curidx = qfl->qf_index;
-if (qf_list_empty(qi, qf_idx))
+if (qf_list_empty(qfl))
 	// For empty lists, current index is set to 0
 	curidx = 0;
 return dict_add_number(retdict, "idx", curidx);
 }
 // List is not present or is empty
 if (qf_stack_empty(qi) || qf_idx == INVALID_QFIDX)
 	return qf_getprop_defaults(qi, flags, wp != NULL, retdict);
-qfl = &qi->qf_lists[qf_idx];
+qfl = qf_get_list(qi, qf_idx);
 if (flags & QF_GETLIST_TITLE)
 	status = qf_getprop_title(qfl, retdict);
 if ((status == OK) && (flags & QF_GETLIST_NR))
 	status = dict_add_number(retdict, "nr", qf_idx + 1);
 if ((status == OK) && (flags & QF_GETLIST_CONTEXT))
 	status = qf_getprop_ctx(qfl, retdict);
 if ((status == OK) && (flags & QF_GETLIST_ID))
 	status = dict_add_number(retdict, "id", qfl->qf_id);
 if ((status == OK) && (flags & QF_GETLIST_IDX))
-	status = qf_getprop_idx(qi, qf_idx, retdict);
+	status = qf_getprop_idx(qfl, retdict);
 if ((status == OK) && (flags & QF_GETLIST_SIZE))
 	status = dict_add_number(retdict, "size", qfl->qf_count);
 if ((status == OK) && (flags & QF_GETLIST_TICK))
 	status = dict_add_number(retdict, "changedtick", qfl->qf_changedtick);
 if ((status == OK) && (wp != NULL) && (flags & QF_GETLIST_FILEWINID))
 * items in the dict 'd'. If it is a valid error entry, then set 'valid_entry'
 * to TRUE.
 */
 static int
 qf_add_entry_from_dict(
-	qf_info_T	*qi,
+	qf_list_T	*qfl,
-	int		qf_idx,
 	dict_T		*d,
 	int		first_entry,
 	int		*valid_entry)
 {
 static int	did_bufnr_emsg;
 // If the 'valid' field is present it overrules the detected value.
 if ((dict_find(d, (char_u *)"valid", -1)) != NULL)
 	valid = (int)dict_get_number(d, (char_u *)"valid");
-status =  qf_add_entry(qi,
+status =  qf_add_entry(qfl,
-			qf_idx,
 			NULL,		// dir
 			filename,
 			module,
 			bufnum,
 			text,
 	int		qf_idx,
 	list_T		*list,
 	char_u		*title,
 	int		action)
 {
-qf_list_T	*qfl = &qi->qf_lists[qf_idx];
+qf_list_T	*qfl = qf_get_list(qi, qf_idx);
 listitem_T	*li;
 dict_T	*d;
 qfline_T	*old_last = NULL;
 int		retval = OK;
 int		valid_entry = FALSE;
 if (action == ' ' || qf_idx == qi->qf_listcount)
 {
 	// make place for a new list
 	qf_new_list(qi, title);
 	qf_idx = qi->qf_curlist;
-	qfl = &qi->qf_lists[qf_idx];
+	qfl = qf_get_list(qi, qf_idx);
 }
-else if (action == 'a' && !qf_list_empty(qi, qf_idx))
+else if (action == 'a' && !qf_list_empty(qfl))
 	// Adding to existing list, use last entry.
 	old_last = qfl->qf_last;
 else if (action == 'r')
 {
 	qf_free_items(qfl);
 	d = li->li_tv.vval.v_dict;
 	if (d == NULL)
 	    continue;
-	retval = qf_add_entry_from_dict(qi, qf_idx, d, li == list->lv_first,
+	retval = qf_add_entry_from_dict(qfl, d, li == list->lv_first,
 								&valid_entry);
 	if (retval == FAIL)
 	    break;
 }
 if (action != 'a')
 	qfl->qf_ptr = qfl->qf_start;
 // Update the current error index if not appending to the list or if the
 // list was empty before and it is not empty now.
-if ((action != 'a' || qfl->qf_index == 0) && !qf_list_empty(qi, qf_idx))
+if ((action != 'a' || qfl->qf_index == 0) && !qf_list_empty(qfl))
 	qfl->qf_index = 1;
 // Don't update the cursor in quickfix window when appending entries
 qf_update_buffer(qi, old_last);
 * Set the quickfix list title.
 */
 static int
 qf_setprop_title(qf_info_T *qi, int qf_idx, dict_T *what, dictitem_T *di)
 {
-qf_list_T	*qfl = &qi->qf_lists[qf_idx];
+qf_list_T	*qfl = qf_get_list(qi, qf_idx);
 if (di->di_tv.v_type != VAR_STRING)
 	return FAIL;
 vim_free(qfl->qf_title);
 	qi->qf_curlist = qf_idx;
 	qf_new_list(qi, title);
 	qf_idx = qi->qf_curlist;
 }
-qfl = &qi->qf_lists[qf_idx];
+qfl = qf_get_list(qi, qf_idx);
 if ((di = dict_find(what, (char_u *)"title", -1)) != NULL)
 	retval = qf_setprop_title(qi, qf_idx, what, di);
 if ((di = dict_find(what, (char_u *)"items", -1)) != NULL)
 	retval = qf_setprop_items(qi, qf_idx, di, action);
 if ((di = dict_find(what, (char_u *)"lines", -1)) != NULL)
 	    // remove trailing CR, LF, spaces, etc.
 	    while (l > 0 && line[l - 1] <= ' ')
 		line[--l] = NUL;
-	    if (qf_add_entry(qi,
+	    if (qf_add_entry(qf_get_curlist(qi),
-			qi->qf_curlist,
 			NULL,	// dir
 			fname,
 			NULL,
 			0,
 			line,
 	    return;
 	}
 }
 // Jump to first match.
-if (!qf_list_empty(qi, qi->qf_curlist))
+if (!qf_list_empty(qf_get_curlist(qi)))
 	qf_jump(qi, 0, 0, FALSE);
 else
 	semsg(_(e_nomatch2), eap->arg);
 decr_quickfix_busy();

Mercurial > vim

comparison src/quickfix.c @ 16050:c19853508d3e v8.1.1030