#include "vim.h"
#if defined(FEAT_QUICKFIX) || defined(PROTO)
struct dir_stack_T
{
struct dir_stack_T *next;
char_u *dirname;
};
typedef struct qfline_S qfline_T;
struct qfline_S
{
qfline_T *qf_next;
qfline_T *qf_prev;
linenr_T qf_lnum;
int qf_fnum;
int qf_col;
int qf_nr;
char_u *qf_pattern;
char_u *qf_text;
char_u qf_viscol;
char_u qf_cleared;
char_u qf_type;
char_u qf_valid;
};
#define LISTCOUNT 10
typedef struct qf_list_S
{
int_u qf_id;
qfline_T *qf_start;
qfline_T *qf_last;
qfline_T *qf_ptr;
int qf_count;
int qf_index;
int qf_nonevalid;
char_u *qf_title;
typval_T *qf_ctx;
struct dir_stack_T *qf_dir_stack;
char_u *qf_directory;
struct dir_stack_T *qf_file_stack;
char_u *qf_currfile;
int qf_multiline;
int qf_multiignore;
int qf_multiscan;
} qf_list_T;
struct qf_info_S
{
int qf_refcount;
int qf_listcount;
int qf_curlist;
qf_list_T qf_lists[LISTCOUNT];
};
static qf_info_T ql_info;
static int_u last_qf_id = 0;
#define FMT_PATTERNS 10
typedef struct efm_S efm_T;
struct efm_S
{
regprog_T *prog;
efm_T *next;
char_u addr[FMT_PATTERNS];
char_u prefix;
char_u flags;
int conthere;
};
static efm_T *fmt_start = NULL;
static int qf_init_ext(qf_info_T *qi, int qf_idx, char_u *efile, buf_T *buf, typval_T *tv, char_u *errorformat, int newlist, linenr_T lnumfirst, linenr_T lnumlast, char_u *qf_title, char_u *enc);
static void qf_store_title(qf_info_T *qi, int qf_idx, char_u *title);
static void qf_new_list(qf_info_T *qi, char_u *qf_title);
static void ll_free_all(qf_info_T **pqi);
static int qf_add_entry(qf_info_T *qi, int qf_idx, char_u *dir, char_u *fname, int bufnum, char_u *mesg, long lnum, int col, int vis_col, char_u *pattern, int nr, int type, int valid);
static qf_info_T *ll_new_list(void);
static void qf_free(qf_info_T *qi, int idx);
static char_u *qf_types(int, int);
static int qf_get_fnum(qf_info_T *qi, int qf_idx, 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_info_T *qi, int qf_idx, char_u *);
static void qf_fmt_text(char_u *text, char_u *buf, int bufsize);
static void qf_clean_dir_stack(struct dir_stack_T **);
static int qf_win_pos_update(qf_info_T *qi, int old_qf_index);
static int is_qf_win(win_T *win, qf_info_T *qi);
static win_T *qf_find_win(qf_info_T *qi);
static buf_T *qf_find_buf(qf_info_T *qi);
static void qf_update_buffer(qf_info_T *qi, qfline_T *old_last);
static void qf_set_title_var(qf_info_T *qi);
static void qf_fill_buffer(qf_info_T *qi, buf_T *buf, qfline_T *old_last);
static char_u *get_mef_name(void);
static void restore_start_dir(char_u *dirname_start);
static buf_T *load_dummy_buffer(char_u *fname, char_u *dirname_start, char_u *resulting_dir);
static void wipe_dummy_buffer(buf_T *buf, char_u *dirname_start);
static void unload_dummy_buffer(buf_T *buf, char_u *dirname_start);
static qf_info_T *ll_get_or_alloc_list(win_T *);
#define IS_QF_WINDOW(wp) (bt_quickfix(wp->w_buffer) && wp->w_llist_ref == NULL)
#define IS_LL_WINDOW(wp) (bt_quickfix(wp->w_buffer) && wp->w_llist_ref != NULL)
#define GET_LOC_LIST(wp) (IS_LL_WINDOW(wp) ? wp->w_llist_ref : wp->w_llist)
static char_u *qf_last_bufname = NULL;
static bufref_T qf_last_bufref = {NULL, 0, 0};
int
qf_init(win_T *wp,
char_u *efile,
char_u *errorformat,
int newlist,
char_u *qf_title,
char_u *enc)
{
qf_info_T *qi = &ql_info;
if (wp != NULL)
{
qi = ll_get_or_alloc_list(wp);
if (qi == NULL)
return FAIL;
}
return qf_init_ext(qi, qi->qf_curlist, efile, curbuf, NULL, errorformat,
newlist, (linenr_T)0, (linenr_T)0, qf_title, enc);
}
#define LINE_MAXLEN 4096
static struct fmtpattern
{
char_u convchar;
char *pattern;
} fmt_pat[FMT_PATTERNS] =
{
{'f', ".\\+"},
{'n', "\\d\\+"},
{'l', "\\d\\+"},
{'c', "\\d\\+"},
{'t', "."},
{'m', ".\\+"},
{'r', ".*"},
{'p', "[- .]*"},
{'v', "\\d\\+"},
{'s', ".\\+"}
};
static int
efm_to_regpat(
char_u *efm,
int len,
efm_T *fmt_ptr,
char_u *regpat,
char_u *errmsg)
{
char_u *ptr;
char_u *efmp;
char_u *srcptr;
int round;
int idx = 0;
ptr = regpat;
*ptr++ = '^';
round = 0;
for (efmp = efm; efmp < efm + len; ++efmp)
{
if (*efmp == '%')
{
++efmp;
for (idx = 0; idx < FMT_PATTERNS; ++idx)
if (fmt_pat[idx].convchar == *efmp)
break;
if (idx < FMT_PATTERNS)
{
if (fmt_ptr->addr[idx])
{
sprintf((char *)errmsg,
_("E372: Too many %%%c in format string"), *efmp);
EMSG(errmsg);
return -1;
}
if ((idx
&& idx < 6
&& vim_strchr((char_u *)"DXOPQ",
fmt_ptr->prefix) != NULL)
|| (idx == 6
&& vim_strchr((char_u *)"OPQ",
fmt_ptr->prefix) == NULL))
{
sprintf((char *)errmsg,
_("E373: Unexpected %%%c in format string"), *efmp);
EMSG(errmsg);
return -1;
}
fmt_ptr->addr[idx] = (char_u)++round;
*ptr++ = '\\';
*ptr++ = '(';
#ifdef BACKSLASH_IN_FILENAME
if (*efmp == 'f')
{
STRCPY(ptr, "\\%(\\a:\\)\\=");
ptr += 10;
}
#endif
if (*efmp == 'f' && efmp[1] != NUL)
{
if (efmp[1] != '\\' && efmp[1] != '%')
{
STRCPY(ptr, ".\\{-1,}");
ptr += 7;
}
else
{
STRCPY(ptr, "\\f\\+");
ptr += 4;
}
}
else
{
srcptr = (char_u *)fmt_pat[idx].pattern;
while ((*ptr = *srcptr++) != NUL)
++ptr;
}
*ptr++ = '\\';
*ptr++ = ')';
}
else if (*efmp == '*')
{
if (*++efmp == '[' || *efmp == '\\')
{
if ((*ptr++ = *efmp) == '[')
{
if (efmp[1] == '^')
*ptr++ = *++efmp;
if (efmp < efm + len)
{
*ptr++ = *++efmp;
while (efmp < efm + len
&& (*ptr++ = *++efmp) != ']')
;
if (efmp == efm + len)
{
EMSG(_("E374: Missing ] in format string"));
return -1;
}
}
}
else if (efmp < efm + len)
*ptr++ = *++efmp;
*ptr++ = '\\';
*ptr++ = '+';
}
else
{
sprintf((char *)errmsg,
_("E375: Unsupported %%%c in format string"), *efmp);
EMSG(errmsg);
return -1;
}
}
else if (vim_strchr((char_u *)"%\\.^$~[", *efmp) != NULL)
*ptr++ = *efmp;
else if (*efmp == '#')
*ptr++ = '*';
else if (*efmp == '>')
fmt_ptr->conthere = TRUE;
else if (efmp == efm + 1)
{
if (vim_strchr((char_u *)"+-", *efmp) != NULL)
fmt_ptr->flags = *efmp++;
if (vim_strchr((char_u *)"DXAEWICZGOPQ", *efmp) != NULL)
fmt_ptr->prefix = *efmp;
else
{
sprintf((char *)errmsg,
_("E376: Invalid %%%c in format string prefix"), *efmp);
EMSG(errmsg);
return -1;
}
}
else
{
sprintf((char *)errmsg,
_("E377: Invalid %%%c in format string"), *efmp);
EMSG(errmsg);
return -1;
}
}
else
{
if (*efmp == '\\' && efmp + 1 < efm + len)
++efmp;
else if (vim_strchr((char_u *)".*^$~[", *efmp) != NULL)
*ptr++ = '\\';
if (*efmp)
*ptr++ = *efmp;
}
}
*ptr++ = '$';
*ptr = NUL;
return 0;
}
static void
free_efm_list(efm_T **efm_first)
{
efm_T *efm_ptr;
for (efm_ptr = *efm_first; efm_ptr != NULL; efm_ptr = *efm_first)
{
*efm_first = efm_ptr->next;
vim_regfree(efm_ptr->prog);
vim_free(efm_ptr);
}
fmt_start = NULL;
}
static efm_T *
parse_efm_option(char_u *efm)
{
char_u *errmsg = NULL;
int errmsglen;
efm_T *fmt_ptr = NULL;
efm_T *fmt_first = NULL;
efm_T *fmt_last = NULL;
char_u *fmtstr = NULL;
int len;
int i;
int round;
errmsglen = CMDBUFFSIZE + 1;
errmsg = alloc_id(errmsglen, aid_qf_errmsg);
if (errmsg == NULL)
goto parse_efm_end;
i = (FMT_PATTERNS * 3) + ((int)STRLEN(efm) << 2);
for (round = FMT_PATTERNS; round > 0; )
i += (int)STRLEN(fmt_pat[--round].pattern);
#ifdef BACKSLASH_IN_FILENAME
i += 12;
#else
i += 2;
#endif
if ((fmtstr = alloc(i)) == NULL)
goto parse_efm_error;
while (efm[0] != NUL)
{
fmt_ptr = (efm_T *)alloc_clear((unsigned)sizeof(efm_T));
if (fmt_ptr == NULL)
goto parse_efm_error;
if (fmt_first == NULL)
fmt_first = fmt_ptr;
else
fmt_last->next = fmt_ptr;
fmt_last = fmt_ptr;
for (len = 0; efm[len] != NUL && efm[len] != ','; ++len)
if (efm[len] == '\\' && efm[len + 1] != NUL)
++len;
if (efm_to_regpat(efm, len, fmt_ptr, fmtstr, errmsg) == -1)
goto parse_efm_error;
if ((fmt_ptr->prog = vim_regcomp(fmtstr, RE_MAGIC + RE_STRING)) == NULL)
goto parse_efm_error;
efm = skip_to_option_part(efm + len);
}
if (fmt_first == NULL)
EMSG(_("E378: 'errorformat' contains no pattern"));
goto parse_efm_end;
parse_efm_error:
free_efm_list(&fmt_first);
parse_efm_end:
vim_free(fmtstr);
vim_free(errmsg);
return fmt_first;
}
enum {
QF_FAIL = 0,
QF_OK = 1,
QF_END_OF_INPUT = 2,
QF_NOMEM = 3,
QF_IGNORE_LINE = 4
};
typedef struct {
char_u *linebuf;
int linelen;
char_u *growbuf;
int growbufsiz;
FILE *fd;
typval_T *tv;
char_u *p_str;
listitem_T *p_li;
buf_T *buf;
linenr_T buflnum;
linenr_T lnumlast;
vimconv_T vc;
} qfstate_T;
static char_u *
qf_grow_linebuf(qfstate_T *state, int newsz)
{
state->linelen = newsz > LINE_MAXLEN ? LINE_MAXLEN - 1 : newsz;
if (state->growbuf == NULL)
{
state->growbuf = alloc(state->linelen + 1);
if (state->growbuf == NULL)
return NULL;
state->growbufsiz = state->linelen;
}
else if (state->linelen > state->growbufsiz)
{
state->growbuf = vim_realloc(state->growbuf, state->linelen + 1);
if (state->growbuf == NULL)
return NULL;
state->growbufsiz = state->linelen;
}
return state->growbuf;
}
static int
qf_get_next_str_line(qfstate_T *state)
{
char_u *p_str = state->p_str;
char_u *p;
int len;
if (*p_str == NUL)
return QF_END_OF_INPUT;
p = vim_strchr(p_str, '\n');
if (p != NULL)
len = (int)(p - p_str) + 1;
else
len = (int)STRLEN(p_str);
if (len > IOSIZE - 2)
{
state->linebuf = qf_grow_linebuf(state, len);
if (state->linebuf == NULL)
return QF_NOMEM;
}
else
{
state->linebuf = IObuff;
state->linelen = len;
}
vim_strncpy(state->linebuf, p_str, state->linelen);
p_str += len;
state->p_str = p_str;
return QF_OK;
}
static int
qf_get_next_list_line(qfstate_T *state)
{
listitem_T *p_li = state->p_li;
int len;
while (p_li != NULL
&& (p_li->li_tv.v_type != VAR_STRING
|| p_li->li_tv.vval.v_string == NULL))
p_li = p_li->li_next;
if (p_li == NULL)
{
state->p_li = NULL;
return QF_END_OF_INPUT;
}
len = (int)STRLEN(p_li->li_tv.vval.v_string);
if (len > IOSIZE - 2)
{
state->linebuf = qf_grow_linebuf(state, len);
if (state->linebuf == NULL)
return QF_NOMEM;
}
else
{
state->linebuf = IObuff;
state->linelen = len;
}
vim_strncpy(state->linebuf, p_li->li_tv.vval.v_string, state->linelen);
state->p_li = p_li->li_next;
return QF_OK;
}
static int
qf_get_next_buf_line(qfstate_T *state)
{
char_u *p_buf = NULL;
int len;
if (state->buflnum > state->lnumlast)
return QF_END_OF_INPUT;
p_buf = ml_get_buf(state->buf, state->buflnum, FALSE);
state->buflnum += 1;
len = (int)STRLEN(p_buf);
if (len > IOSIZE - 2)
{
state->linebuf = qf_grow_linebuf(state, len);
if (state->linebuf == NULL)
return QF_NOMEM;
}
else
{
state->linebuf = IObuff;
state->linelen = len;
}
vim_strncpy(state->linebuf, p_buf, state->linelen);
return QF_OK;
}
static int
qf_get_next_file_line(qfstate_T *state)
{
int discard;
int growbuflen;
if (fgets((char *)IObuff, IOSIZE, state->fd) == NULL)
return QF_END_OF_INPUT;
discard = FALSE;
state->linelen = (int)STRLEN(IObuff);
if (state->linelen == IOSIZE - 1 && !(IObuff[state->linelen - 1] == '\n'))
{
if (state->growbuf == NULL)
{
state->growbufsiz = 2 * (IOSIZE - 1);
state->growbuf = alloc(state->growbufsiz);
if (state->growbuf == NULL)
return QF_NOMEM;
}
memcpy(state->growbuf, IObuff, IOSIZE - 1);
growbuflen = state->linelen;
for (;;)
{
if (fgets((char *)state->growbuf + growbuflen,
state->growbufsiz - growbuflen, state->fd) == NULL)
break;
state->linelen = (int)STRLEN(state->growbuf + growbuflen);
growbuflen += state->linelen;
if ((state->growbuf)[growbuflen - 1] == '\n')
break;
if (state->growbufsiz == LINE_MAXLEN)
{
discard = TRUE;
break;
}
state->growbufsiz = 2 * state->growbufsiz < LINE_MAXLEN
? 2 * state->growbufsiz : LINE_MAXLEN;
state->growbuf = vim_realloc(state->growbuf, state->growbufsiz);
if (state->growbuf == NULL)
return QF_NOMEM;
}
while (discard)
{
if (fgets((char *)IObuff, IOSIZE, state->fd) == NULL
|| (int)STRLEN(IObuff) < IOSIZE - 1
|| IObuff[IOSIZE - 1] == '\n')
break;
}
state->linebuf = state->growbuf;
state->linelen = growbuflen;
}
else
state->linebuf = IObuff;
#ifdef FEAT_MBYTE
if (state->vc.vc_type != CONV_NONE && has_non_ascii(state->linebuf))
{
char_u *line;
line = string_convert(&state->vc, state->linebuf, &state->linelen);
if (line != NULL)
{
if (state->linelen < IOSIZE)
{
STRCPY(state->linebuf, line);
vim_free(line);
}
else
{
vim_free(state->growbuf);
state->linebuf = state->growbuf = line;
state->growbufsiz = state->linelen < LINE_MAXLEN
? state->linelen : LINE_MAXLEN;
}
}
}
#endif
return QF_OK;
}
static int
qf_get_nextline(qfstate_T *state)
{
int status = QF_FAIL;
if (state->fd == NULL)
{
if (state->tv != NULL)
{
if (state->tv->v_type == VAR_STRING)
status = qf_get_next_str_line(state);
else if (state->tv->v_type == VAR_LIST)
status = qf_get_next_list_line(state);
}
else
status = qf_get_next_buf_line(state);
}
else
status = qf_get_next_file_line(state);
if (status != QF_OK)
return status;
if (state->linelen > 0 && state->linebuf[state->linelen - 1] == '\n')
{
state->linebuf[state->linelen - 1] = NUL;
#ifdef USE_CRNL
if (state->linelen > 1 && state->linebuf[state->linelen - 2] == '\r')
state->linebuf[state->linelen - 2] = NUL;
#endif
}
#ifdef FEAT_MBYTE
remove_bom(state->linebuf);
#endif
return QF_OK;
}
typedef struct {
char_u *namebuf;
char_u *errmsg;
int errmsglen;
long lnum;
int col;
char_u use_viscol;
char_u *pattern;
int enr;
int type;
int valid;
} qffields_T;
static int
qf_parse_line(
qf_info_T *qi,
int qf_idx,
char_u *linebuf,
int linelen,
efm_T *fmt_first,
qffields_T *fields)
{
efm_T *fmt_ptr;
char_u *ptr;
int len;
int i;
int idx = 0;
char_u *tail = NULL;
regmatch_T regmatch;
qf_list_T *qfl = &qi->qf_lists[qf_idx];
regmatch.rm_ic = TRUE;
if (fmt_start == NULL)
fmt_ptr = fmt_first;
else
{
fmt_ptr = fmt_start;
fmt_start = NULL;
}
fields->valid = TRUE;
restofline:
for ( ; fmt_ptr != NULL; fmt_ptr = fmt_ptr->next)
{
int r;
idx = fmt_ptr->prefix;
if (qfl->qf_multiscan && vim_strchr((char_u *)"OPQ", idx) == NULL)
continue;
fields->namebuf[0] = NUL;
fields->pattern[0] = NUL;
if (!qfl->qf_multiscan)
fields->errmsg[0] = NUL;
fields->lnum = 0;
fields->col = 0;
fields->use_viscol = FALSE;
fields->enr = -1;
fields->type = 0;
tail = NULL;
regmatch.regprog = fmt_ptr->prog;
r = vim_regexec(®match, linebuf, (colnr_T)0);
fmt_ptr->prog = regmatch.regprog;
if (r)
{
if ((idx == 'C' || idx == 'Z') && !qfl->qf_multiline)
continue;
if (vim_strchr((char_u *)"EWI", idx) != NULL)
fields->type = idx;
else
fields->type = 0;
if ((i = (int)fmt_ptr->addr[0]) > 0)
{
int c;
if (regmatch.startp[i] == NULL || regmatch.endp[i] == NULL)
continue;
c = *regmatch.endp[i];
*regmatch.endp[i] = NUL;
expand_env(regmatch.startp[i], fields->namebuf, CMDBUFFSIZE);
*regmatch.endp[i] = c;
if (vim_strchr((char_u *)"OPQ", idx) != NULL
&& mch_getperm(fields->namebuf) == -1)
continue;
}
if ((i = (int)fmt_ptr->addr[1]) > 0)
{
if (regmatch.startp[i] == NULL)
continue;
fields->enr = (int)atol((char *)regmatch.startp[i]);
}
if ((i = (int)fmt_ptr->addr[2]) > 0)
{
if (regmatch.startp[i] == NULL)
continue;
fields->lnum = atol((char *)regmatch.startp[i]);
}
if ((i = (int)fmt_ptr->addr[3]) > 0)
{
if (regmatch.startp[i] == NULL)
continue;
fields->col = (int)atol((char *)regmatch.startp[i]);
}
if ((i = (int)fmt_ptr->addr[4]) > 0)
{
if (regmatch.startp[i] == NULL)
continue;
fields->type = *regmatch.startp[i];
}
if (fmt_ptr->flags == '+' && !qfl->qf_multiscan)
{
if (linelen >= fields->errmsglen)
{
if ((fields->errmsg = vim_realloc(fields->errmsg,
linelen + 1)) == NULL)
return QF_NOMEM;
fields->errmsglen = linelen + 1;
}
vim_strncpy(fields->errmsg, linebuf, linelen);
}
else if ((i = (int)fmt_ptr->addr[5]) > 0)
{
if (regmatch.startp[i] == NULL || regmatch.endp[i] == NULL)
continue;
len = (int)(regmatch.endp[i] - regmatch.startp[i]);
if (len >= fields->errmsglen)
{
if ((fields->errmsg = vim_realloc(fields->errmsg, len + 1))
== NULL)
return QF_NOMEM;
fields->errmsglen = len + 1;
}
vim_strncpy(fields->errmsg, regmatch.startp[i], len);
}
if ((i = (int)fmt_ptr->addr[6]) > 0)
{
if (regmatch.startp[i] == NULL)
continue;
tail = regmatch.startp[i];
}
if ((i = (int)fmt_ptr->addr[7]) > 0)
{
char_u *match_ptr;
if (regmatch.startp[i] == NULL || regmatch.endp[i] == NULL)
continue;
fields->col = 0;
for (match_ptr = regmatch.startp[i];
match_ptr != regmatch.endp[i]; ++match_ptr)
{
++fields->col;
if (*match_ptr == TAB)
{
fields->col += 7;
fields->col -= fields->col % 8;
}
}
++fields->col;
fields->use_viscol = TRUE;
}
if ((i = (int)fmt_ptr->addr[8]) > 0)
{
if (regmatch.startp[i] == NULL)
continue;
fields->col = (int)atol((char *)regmatch.startp[i]);
fields->use_viscol = TRUE;
}
if ((i = (int)fmt_ptr->addr[9]) > 0)
{
if (regmatch.startp[i] == NULL || regmatch.endp[i] == NULL)
continue;
len = (int)(regmatch.endp[i] - regmatch.startp[i]);
if (len > CMDBUFFSIZE - 5)
len = CMDBUFFSIZE - 5;
STRCPY(fields->pattern, "^\\V");
STRNCAT(fields->pattern, regmatch.startp[i], len);
fields->pattern[len + 3] = '\\';
fields->pattern[len + 4] = '$';
fields->pattern[len + 5] = NUL;
}
break;
}
}
qfl->qf_multiscan = FALSE;
if (fmt_ptr == NULL || idx == 'D' || idx == 'X')
{
if (fmt_ptr != NULL)
{
if (idx == 'D')
{
if (*fields->namebuf == NUL)
{
EMSG(_("E379: Missing or empty directory name"));
return QF_FAIL;
}
qfl->qf_directory =
qf_push_dir(fields->namebuf, &qfl->qf_dir_stack, FALSE);
if (qfl->qf_directory == NULL)
return QF_FAIL;
}
else if (idx == 'X')
qfl->qf_directory = qf_pop_dir(&qfl->qf_dir_stack);
}
fields->namebuf[0] = NUL;
fields->lnum = 0;
fields->valid = FALSE;
if (linelen >= fields->errmsglen)
{
if ((fields->errmsg = vim_realloc(fields->errmsg,
linelen + 1)) == NULL)
return QF_NOMEM;
fields->errmsglen = linelen + 1;
}
vim_strncpy(fields->errmsg, linebuf, linelen);
if (fmt_ptr == NULL)
qfl->qf_multiline = qfl->qf_multiignore = FALSE;
}
else if (fmt_ptr != NULL)
{
if (fmt_ptr->conthere)
fmt_start = fmt_ptr;
if (vim_strchr((char_u *)"AEWI", idx) != NULL)
{
qfl->qf_multiline = TRUE;
qfl->qf_multiignore = FALSE;
}
else if (vim_strchr((char_u *)"CZ", idx) != NULL)
{
if (!qfl->qf_multiignore)
{
qfline_T *qfprev = qfl->qf_last;
if (qfprev == NULL)
return QF_FAIL;
if (*fields->errmsg && !qfl->qf_multiignore)
{
len = (int)STRLEN(qfprev->qf_text);
if ((ptr = alloc((unsigned)(len + STRLEN(fields->errmsg) + 2)))
== NULL)
return QF_FAIL;
STRCPY(ptr, qfprev->qf_text);
vim_free(qfprev->qf_text);
qfprev->qf_text = ptr;
*(ptr += len) = '\n';
STRCPY(++ptr, fields->errmsg);
}
if (qfprev->qf_nr == -1)
qfprev->qf_nr = fields->enr;
if (vim_isprintc(fields->type) && !qfprev->qf_type)
qfprev->qf_type = fields->type;
if (!qfprev->qf_lnum)
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,
qfl->qf_directory,
*fields->namebuf || qfl->qf_directory != NULL
? fields->namebuf
: qfl->qf_currfile != NULL && fields->valid
? qfl->qf_currfile : 0);
}
if (idx == 'Z')
qfl->qf_multiline = qfl->qf_multiignore = FALSE;
line_breakcheck();
return QF_IGNORE_LINE;
}
else if (vim_strchr((char_u *)"OPQ", idx) != NULL)
{
fields->valid = FALSE;
if (*fields->namebuf == NUL || mch_getperm(fields->namebuf) >= 0)
{
if (*fields->namebuf && idx == 'P')
qfl->qf_currfile =
qf_push_dir(fields->namebuf, &qfl->qf_file_stack, TRUE);
else if (idx == 'Q')
qfl->qf_currfile = qf_pop_dir(&qfl->qf_file_stack);
*fields->namebuf = NUL;
if (tail && *tail)
{
STRMOVE(IObuff, skipwhite(tail));
qfl->qf_multiscan = TRUE;
goto restofline;
}
}
}
if (fmt_ptr->flags == '-')
{
if (qfl->qf_multiline)
qfl->qf_multiignore = TRUE;
return QF_IGNORE_LINE;
}
}
return QF_OK;
}
static int
qf_init_ext(
qf_info_T *qi,
int qf_idx,
char_u *efile,
buf_T *buf,
typval_T *tv,
char_u *errorformat,
int newlist,
linenr_T lnumfirst,
linenr_T lnumlast,
char_u *qf_title,
char_u *enc)
{
qf_list_T *qfl;
qfstate_T state;
qffields_T fields;
qfline_T *old_last = NULL;
int adding = FALSE;
static efm_T *fmt_first = NULL;
char_u *efm;
static char_u *last_efm = NULL;
int retval = -1;
int status;
vim_free(qf_last_bufname);
qf_last_bufname = NULL;
vim_memset(&state, 0, sizeof(state));
vim_memset(&fields, 0, sizeof(fields));
#ifdef FEAT_MBYTE
state.vc.vc_type = CONV_NONE;
if (enc != NULL && *enc != NUL)
convert_setup(&state.vc, enc, p_enc);
#endif
fields.namebuf = alloc_id(CMDBUFFSIZE + 1, aid_qf_namebuf);
fields.errmsglen = CMDBUFFSIZE + 1;
fields.errmsg = alloc_id(fields.errmsglen, aid_qf_errmsg);
fields.pattern = alloc_id(CMDBUFFSIZE + 1, aid_qf_pattern);
if (fields.namebuf == NULL || fields.errmsg == NULL || fields.pattern == NULL)
goto qf_init_end;
if (efile != NULL && (state.fd = mch_fopen((char *)efile, "r")) == NULL)
{
EMSG2(_(e_openerrf), efile);
goto qf_init_end;
}
if (newlist || qf_idx == qi->qf_listcount)
{
qf_new_list(qi, qf_title);
qf_idx = qi->qf_curlist;
}
else
{
adding = TRUE;
if (qi->qf_lists[qf_idx].qf_count > 0)
old_last = qi->qf_lists[qf_idx].qf_last;
}
qfl = &qi->qf_lists[qf_idx];
if (errorformat == p_efm && tv == NULL && *buf->b_p_efm != NUL)
efm = buf->b_p_efm;
else
efm = errorformat;
if (last_efm == NULL || (STRCMP(last_efm, efm) != 0))
{
vim_free(last_efm);
last_efm = NULL;
free_efm_list(&fmt_first);
fmt_first = parse_efm_option(efm);
if (fmt_first != NULL)
last_efm = vim_strsave(efm);
}
if (fmt_first == NULL)
goto error2;
got_int = FALSE;
if (tv != NULL)
{
if (tv->v_type == VAR_STRING)
state.p_str = tv->vval.v_string;
else if (tv->v_type == VAR_LIST)
state.p_li = tv->vval.v_list->lv_first;
state.tv = tv;
}
state.buf = buf;
state.buflnum = lnumfirst;
state.lnumlast = lnumlast;
while (!got_int)
{
status = qf_get_nextline(&state);
if (status == QF_NOMEM)
goto qf_init_end;
if (status == QF_END_OF_INPUT)
break;
status = qf_parse_line(qi, qf_idx, 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,
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),
0,
fields.errmsg,
fields.lnum,
fields.col,
fields.use_viscol,
fields.pattern,
fields.enr,
fields.type,
fields.valid) == FAIL)
goto error2;
line_breakcheck();
}
if (state.fd == NULL || !ferror(state.fd))
{
if (qfl->qf_index == 0)
{
qfl->qf_ptr = qfl->qf_start;
qfl->qf_index = 1;
qfl->qf_nonevalid = TRUE;
}
else
{
qfl->qf_nonevalid = FALSE;
if (qfl->qf_ptr == NULL)
qfl->qf_ptr = qfl->qf_start;
}
retval = qfl->qf_count;
goto qf_init_end;
}
EMSG(_(e_readerrf));
error2:
if (!adding)
{
qf_free(qi, qi->qf_curlist);
qi->qf_listcount--;
if (qi->qf_curlist > 0)
--qi->qf_curlist;
}
qf_init_end:
if (state.fd != NULL)
fclose(state.fd);
vim_free(fields.namebuf);
vim_free(fields.errmsg);
vim_free(fields.pattern);
vim_free(state.growbuf);
if (qf_idx == qi->qf_curlist)
qf_update_buffer(qi, old_last);
#ifdef FEAT_MBYTE
if (state.vc.vc_type != CONV_NONE)
convert_setup(&state.vc, NULL, NULL);
#endif
return retval;
}
static void
qf_store_title(qf_info_T *qi, int qf_idx, char_u *title)
{
vim_free(qi->qf_lists[qf_idx].qf_title);
qi->qf_lists[qf_idx].qf_title = NULL;
if (title != NULL)
{
char_u *p = alloc((int)STRLEN(title) + 2);
qi->qf_lists[qf_idx].qf_title = p;
if (p != NULL)
sprintf((char *)p, ":%s", (char *)title);
}
}
static void
qf_new_list(qf_info_T *qi, char_u *qf_title)
{
int i;
while (qi->qf_listcount > qi->qf_curlist + 1)
qf_free(qi, --qi->qf_listcount);
if (qi->qf_listcount == LISTCOUNT)
{
qf_free(qi, 0);
for (i = 1; i < LISTCOUNT; ++i)
qi->qf_lists[i - 1] = qi->qf_lists[i];
qi->qf_curlist = LISTCOUNT - 1;
}
else
qi->qf_curlist = qi->qf_listcount++;
vim_memset(&qi->qf_lists[qi->qf_curlist], 0, (size_t)(sizeof(qf_list_T)));
qf_store_title(qi, qi->qf_curlist, qf_title);
qi->qf_lists[qi->qf_curlist].qf_id = ++last_qf_id;
}
static void
ll_free_all(qf_info_T **pqi)
{
int i;
qf_info_T *qi;
qi = *pqi;
if (qi == NULL)
return;
*pqi = NULL;
qi->qf_refcount--;
if (qi->qf_refcount < 1)
{
for (i = 0; i < qi->qf_listcount; ++i)
qf_free(qi, i);
vim_free(qi);
}
}
void
qf_free_all(win_T *wp)
{
int i;
qf_info_T *qi = &ql_info;
if (wp != NULL)
{
ll_free_all(&wp->w_llist);
ll_free_all(&wp->w_llist_ref);
}
else
for (i = 0; i < qi->qf_listcount; ++i)
qf_free(qi, i);
}
static int
qf_add_entry(
qf_info_T *qi,
int qf_idx,
char_u *dir,
char_u *fname,
int bufnum,
char_u *mesg,
long lnum,
int col,
int vis_col,
char_u *pattern,
int nr,
int type,
int valid)
{
qfline_T *qfp;
qfline_T **lastp;
if ((qfp = (qfline_T *)alloc((unsigned)sizeof(qfline_T))) == NULL)
return FAIL;
if (bufnum != 0)
{
buf_T *buf = buflist_findnr(bufnum);
qfp->qf_fnum = bufnum;
if (buf != NULL)
buf->b_has_qf_entry |=
(qi == &ql_info) ? BUF_HAS_QF_ENTRY : BUF_HAS_LL_ENTRY;
}
else
qfp->qf_fnum = qf_get_fnum(qi, qf_idx, dir, fname);
if ((qfp->qf_text = vim_strsave(mesg)) == NULL)
{
vim_free(qfp);
return FAIL;
}
qfp->qf_lnum = lnum;
qfp->qf_col = col;
qfp->qf_viscol = vis_col;
if (pattern == NULL || *pattern == NUL)
qfp->qf_pattern = NULL;
else if ((qfp->qf_pattern = vim_strsave(pattern)) == NULL)
{
vim_free(qfp->qf_text);
vim_free(qfp);
return FAIL;
}
qfp->qf_nr = nr;
if (type != 1 && !vim_isprintc(type))
type = 0;
qfp->qf_type = type;
qfp->qf_valid = valid;
lastp = &qi->qf_lists[qf_idx].qf_last;
if (qi->qf_lists[qf_idx].qf_count == 0)
{
qi->qf_lists[qf_idx].qf_start = qfp;
qi->qf_lists[qf_idx].qf_ptr = qfp;
qi->qf_lists[qf_idx].qf_index = 0;
qfp->qf_prev = NULL;
}
else
{
qfp->qf_prev = *lastp;
(*lastp)->qf_next = qfp;
}
qfp->qf_next = NULL;
qfp->qf_cleared = FALSE;
*lastp = qfp;
++qi->qf_lists[qf_idx].qf_count;
if (qi->qf_lists[qf_idx].qf_index == 0 && qfp->qf_valid)
{
qi->qf_lists[qf_idx].qf_index =
qi->qf_lists[qf_idx].qf_count;
qi->qf_lists[qf_idx].qf_ptr = qfp;
}
return OK;
}
static qf_info_T *
ll_new_list(void)
{
qf_info_T *qi;
qi = (qf_info_T *)alloc((unsigned)sizeof(qf_info_T));
if (qi != NULL)
{
vim_memset(qi, 0, (size_t)(sizeof(qf_info_T)));
qi->qf_refcount++;
}
return qi;
}
static qf_info_T *
ll_get_or_alloc_list(win_T *wp)
{
if (IS_LL_WINDOW(wp))
return wp->w_llist_ref;
ll_free_all(&wp->w_llist_ref);
if (wp->w_llist == NULL)
wp->w_llist = ll_new_list();
return wp->w_llist;
}
void
copy_loclist(win_T *from, win_T *to)
{
qf_info_T *qi;
int idx;
int i;
if (IS_LL_WINDOW(from))
qi = from->w_llist_ref;
else
qi = from->w_llist;
if (qi == NULL)
return;
if ((to->w_llist = ll_new_list()) == NULL)
return;
to->w_llist->qf_listcount = qi->qf_listcount;
for (idx = 0; idx < qi->qf_listcount; idx++)
{
qf_list_T *from_qfl;
qf_list_T *to_qfl;
to->w_llist->qf_curlist = idx;
from_qfl = &qi->qf_lists[idx];
to_qfl = &to->w_llist->qf_lists[idx];
to_qfl->qf_nonevalid = from_qfl->qf_nonevalid;
to_qfl->qf_count = 0;
to_qfl->qf_index = 0;
to_qfl->qf_start = NULL;
to_qfl->qf_last = NULL;
to_qfl->qf_ptr = NULL;
if (from_qfl->qf_title != NULL)
to_qfl->qf_title = vim_strsave(from_qfl->qf_title);
else
to_qfl->qf_title = NULL;
if (from_qfl->qf_ctx != NULL)
{
to_qfl->qf_ctx = alloc_tv();
if (to_qfl->qf_ctx != NULL)
copy_tv(from_qfl->qf_ctx, to_qfl->qf_ctx);
}
else
to_qfl->qf_ctx = NULL;
if (from_qfl->qf_count)
{
qfline_T *from_qfp;
qfline_T *prevp;
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->w_llist,
to->w_llist->qf_curlist,
NULL,
NULL,
0,
from_qfp->qf_text,
from_qfp->qf_lnum,
from_qfp->qf_col,
from_qfp->qf_viscol,
from_qfp->qf_pattern,
from_qfp->qf_nr,
0,
from_qfp->qf_valid) == FAIL)
{
qf_free_all(to);
return;
}
prevp = to->w_llist->qf_lists[to->w_llist->qf_curlist].qf_last;
prevp->qf_fnum = from_qfp->qf_fnum;
prevp->qf_type = from_qfp->qf_type;
if (from_qfl->qf_ptr == from_qfp)
to_qfl->qf_ptr = prevp;
}
}
to_qfl->qf_index = from_qfl->qf_index;
to_qfl->qf_id = ++last_qf_id;
if (to_qfl->qf_nonevalid)
{
to_qfl->qf_ptr = to_qfl->qf_start;
to_qfl->qf_index = 1;
}
}
to->w_llist->qf_curlist = qi->qf_curlist;
}
static int
qf_get_fnum(qf_info_T *qi, int qf_idx, char_u *directory, char_u *fname)
{
char_u *ptr = NULL;
buf_T *buf;
char_u *bufname;
if (fname == NULL || *fname == NUL)
return 0;
#ifdef VMS
vms_remove_version(fname);
#endif
#ifdef BACKSLASH_IN_FILENAME
if (directory != NULL)
slash_adjust(directory);
slash_adjust(fname);
#endif
if (directory != NULL && !vim_isAbsName(fname)
&& (ptr = concat_fnames(directory, fname, TRUE)) != NULL)
{
if (mch_getperm(ptr) < 0)
{
vim_free(ptr);
directory = qf_guess_filepath(qi, qf_idx, fname);
if (directory)
ptr = concat_fnames(directory, fname, TRUE);
else
ptr = vim_strsave(fname);
}
bufname = ptr;
}
else
bufname = fname;
if (qf_last_bufname != NULL && STRCMP(bufname, qf_last_bufname) == 0
&& bufref_valid(&qf_last_bufref))
{
buf = qf_last_bufref.br_buf;
vim_free(ptr);
}
else
{
vim_free(qf_last_bufname);
buf = buflist_new(bufname, NULL, (linenr_T)0, BLN_NOOPT);
if (bufname == ptr)
qf_last_bufname = bufname;
else
qf_last_bufname = vim_strsave(bufname);
set_bufref(&qf_last_bufref, buf);
}
if (buf == NULL)
return 0;
buf->b_has_qf_entry =
(qi == &ql_info) ? BUF_HAS_QF_ENTRY : BUF_HAS_LL_ENTRY;
return buf->b_fnum;
}
static char_u *
qf_push_dir(char_u *dirbuf, struct dir_stack_T **stackptr, int is_file_stack)
{
struct dir_stack_T *ds_new;
struct dir_stack_T *ds_ptr;
ds_new = (struct dir_stack_T *)alloc((unsigned)sizeof(struct dir_stack_T));
if (ds_new == NULL)
return NULL;
ds_new->next = *stackptr;
*stackptr = ds_new;
if (vim_isAbsName(dirbuf)
|| (*stackptr)->next == NULL
|| (*stackptr && is_file_stack))
(*stackptr)->dirname = vim_strsave(dirbuf);
else
{
ds_new = (*stackptr)->next;
(*stackptr)->dirname = NULL;
while (ds_new)
{
vim_free((*stackptr)->dirname);
(*stackptr)->dirname = concat_fnames(ds_new->dirname, dirbuf,
TRUE);
if (mch_isdir((*stackptr)->dirname) == TRUE)
break;
ds_new = ds_new->next;
}
while ((*stackptr)->next != ds_new)
{
ds_ptr = (*stackptr)->next;
(*stackptr)->next = (*stackptr)->next->next;
vim_free(ds_ptr->dirname);
vim_free(ds_ptr);
}
if (ds_new == NULL)
{
vim_free((*stackptr)->dirname);
(*stackptr)->dirname = vim_strsave(dirbuf);
}
}
if ((*stackptr)->dirname != NULL)
return (*stackptr)->dirname;
else
{
ds_ptr = *stackptr;
*stackptr = (*stackptr)->next;
vim_free(ds_ptr);
return NULL;
}
}
static char_u *
qf_pop_dir(struct dir_stack_T **stackptr)
{
struct dir_stack_T *ds_ptr;
if (*stackptr != NULL)
{
ds_ptr = *stackptr;
*stackptr = (*stackptr)->next;
vim_free(ds_ptr->dirname);
vim_free(ds_ptr);
}
return *stackptr ? (*stackptr)->dirname : NULL;
}
static void
qf_clean_dir_stack(struct dir_stack_T **stackptr)
{
struct dir_stack_T *ds_ptr;
while ((ds_ptr = *stackptr) != NULL)
{
*stackptr = (*stackptr)->next;
vim_free(ds_ptr->dirname);
vim_free(ds_ptr);
}
}
static char_u *
qf_guess_filepath(qf_info_T *qi, int qf_idx, char_u *filename)
{
struct dir_stack_T *ds_ptr;
struct dir_stack_T *ds_tmp;
char_u *fullname;
qf_list_T *qfl = &qi->qf_lists[qf_idx];
if (qfl->qf_dir_stack == NULL)
return NULL;
ds_ptr = qfl->qf_dir_stack->next;
fullname = NULL;
while (ds_ptr)
{
vim_free(fullname);
fullname = concat_fnames(ds_ptr->dirname, filename, TRUE);
if ((fullname != NULL) && (mch_getperm(fullname) >= 0))
break;
ds_ptr = ds_ptr->next;
}
vim_free(fullname);
while (qfl->qf_dir_stack->next != ds_ptr)
{
ds_tmp = qfl->qf_dir_stack->next;
qfl->qf_dir_stack->next = qfl->qf_dir_stack->next->next;
vim_free(ds_tmp->dirname);
vim_free(ds_tmp);
}
return ds_ptr==NULL? NULL: ds_ptr->dirname;
}
static int
is_qf_entry_present(qf_info_T *qi, qfline_T *qf_ptr)
{
qf_list_T *qfl;
qfline_T *qfp;
int i;
qfl = &qi->qf_lists[qi->qf_curlist];
for (i = 0, qfp = qfl->qf_start; i < qfl->qf_count;
++i, qfp = qfp->qf_next)
if (qfp == NULL || qfp == qf_ptr)
break;
if (i == qfl->qf_count)
return FALSE;
return TRUE;
}
static qfline_T *
get_next_valid_entry(
qf_info_T *qi,
qfline_T *qf_ptr,
int *qf_index,
int dir)
{
int idx;
int old_qf_fnum;
idx = *qf_index;
old_qf_fnum = qf_ptr->qf_fnum;
do
{
if (idx == qi->qf_lists[qi->qf_curlist].qf_count
|| qf_ptr->qf_next == NULL)
return NULL;
++idx;
qf_ptr = qf_ptr->qf_next;
} while ((!qi->qf_lists[qi->qf_curlist].qf_nonevalid
&& !qf_ptr->qf_valid)
|| (dir == FORWARD_FILE && qf_ptr->qf_fnum == old_qf_fnum));
*qf_index = idx;
return qf_ptr;
}
static qfline_T *
get_prev_valid_entry(
qf_info_T *qi,
qfline_T *qf_ptr,
int *qf_index,
int dir)
{
int idx;
int old_qf_fnum;
idx = *qf_index;
old_qf_fnum = qf_ptr->qf_fnum;
do
{
if (idx == 1 || qf_ptr->qf_prev == NULL)
return NULL;
--idx;
qf_ptr = qf_ptr->qf_prev;
} while ((!qi->qf_lists[qi->qf_curlist].qf_nonevalid
&& !qf_ptr->qf_valid)
|| (dir == BACKWARD_FILE && qf_ptr->qf_fnum == old_qf_fnum));
*qf_index = idx;
return qf_ptr;
}
static qfline_T *
get_nth_valid_entry(
qf_info_T *qi,
int errornr,
qfline_T *qf_ptr,
int *qf_index,
int dir)
{
qfline_T *prev_qf_ptr;
int prev_index;
static char_u *e_no_more_items = (char_u *)N_("E553: No more items");
char_u *err = e_no_more_items;
while (errornr--)
{
prev_qf_ptr = qf_ptr;
prev_index = *qf_index;
if (dir == FORWARD || dir == FORWARD_FILE)
qf_ptr = get_next_valid_entry(qi, qf_ptr, qf_index, dir);
else
qf_ptr = get_prev_valid_entry(qi, qf_ptr, qf_index, dir);
if (qf_ptr == NULL)
{
qf_ptr = prev_qf_ptr;
*qf_index = prev_index;
if (err != NULL)
{
EMSG(_(err));
return NULL;
}
break;
}
err = NULL;
}
return qf_ptr;
}
static qfline_T *
get_nth_entry(
qf_info_T *qi,
int errornr,
qfline_T *qf_ptr,
int *cur_qfidx)
{
int qf_idx = *cur_qfidx;
while (errornr < qf_idx && qf_idx > 1 && qf_ptr->qf_prev != NULL)
{
--qf_idx;
qf_ptr = qf_ptr->qf_prev;
}
while (errornr > qf_idx &&
qf_idx < qi->qf_lists[qi->qf_curlist].qf_count &&
qf_ptr->qf_next != NULL)
{
++qf_idx;
qf_ptr = qf_ptr->qf_next;
}
*cur_qfidx = qf_idx;
return qf_ptr;
}
static int
jump_to_help_window(qf_info_T *qi, int *opened_window)
{
win_T *wp;
int flags;
if (cmdmod.tab != 0)
wp = NULL;
else
FOR_ALL_WINDOWS(wp)
if (bt_help(wp->w_buffer))
break;
if (wp != NULL && wp->w_buffer->b_nwindows > 0)
win_enter(wp, TRUE);
else
{
flags = WSP_HELP;
if (cmdmod.split == 0 && curwin->w_width != Columns
&& curwin->w_width < 80)
flags |= WSP_TOP;
if (qi != &ql_info)
flags |= WSP_NEWLOC;
if (win_split(0, flags) == FAIL)
return FAIL;
*opened_window = TRUE;
if (curwin->w_height < p_hh)
win_setheight((int)p_hh);
if (qi != &ql_info)
{
curwin->w_llist = qi;
qi->qf_refcount++;
}
}
if (!p_im)
restart_edit = 0;
return OK;
}
static int
qf_jump_to_usable_window(int qf_fnum, int *opened_window)
{
win_T *usable_win_ptr = NULL;
int usable_win;
qf_info_T *ll_ref;
int flags;
win_T *win;
win_T *altwin;
usable_win = 0;
ll_ref = curwin->w_llist_ref;
if (ll_ref != NULL)
{
FOR_ALL_WINDOWS(usable_win_ptr)
if (usable_win_ptr->w_llist == ll_ref
&& !bt_quickfix(usable_win_ptr->w_buffer))
{
usable_win = 1;
break;
}
}
if (!usable_win)
{
FOR_ALL_WINDOWS(win)
if (win->w_buffer->b_p_bt[0] == NUL)
{
usable_win = 1;
break;
}
}
if (!usable_win && (swb_flags & SWB_USETAB))
{
tabpage_T *tp;
win_T *wp;
FOR_ALL_TAB_WINDOWS(tp, wp)
{
if (wp->w_buffer->b_fnum == qf_fnum)
{
goto_tabpage_win(tp, wp);
usable_win = 1;
goto win_found;
}
}
}
win_found:
if ((ONE_WINDOW && bt_quickfix(curbuf)) || !usable_win)
{
flags = WSP_ABOVE;
if (ll_ref != NULL)
flags |= WSP_NEWLOC;
if (win_split(0, flags) == FAIL)
return FAIL;
*opened_window = TRUE;
p_swb = empty_option;
swb_flags = 0;
RESET_BINDING(curwin);
if (ll_ref != NULL)
{
curwin->w_llist = ll_ref;
ll_ref->qf_refcount++;
}
}
else
{
if (curwin->w_llist_ref != NULL)
{
win = usable_win_ptr;
if (win == NULL)
{
FOR_ALL_WINDOWS(win)
if (win->w_buffer->b_fnum == qf_fnum)
break;
if (win == NULL)
{
win = curwin;
do
{
if (win->w_buffer->b_p_bt[0] == NUL)
break;
if (win->w_prev == NULL)
win = lastwin;
else
win = win->w_prev;
} while (win != curwin);
}
}
win_goto(win);
if (win->w_llist == NULL)
{
win->w_llist = ll_ref;
ll_ref->qf_refcount++;
}
}
else
{
win = curwin;
altwin = NULL;
for (;;)
{
if (win->w_buffer->b_fnum == qf_fnum)
break;
if (win->w_prev == NULL)
win = lastwin;
else
win = win->w_prev;
if (IS_QF_WINDOW(win))
{
if (altwin != NULL)
win = altwin;
else if (curwin->w_prev != NULL)
win = curwin->w_prev;
else
win = curwin->w_next;
break;
}
if (altwin == NULL && !win->w_p_pvw
&& win->w_buffer->b_p_bt[0] == NUL)
altwin = win;
}
win_goto(win);
}
}
return OK;
}
static int
qf_jump_edit_buffer(
qf_info_T *qi,
qfline_T *qf_ptr,
int forceit,
win_T *oldwin,
int *opened_window,
int *abort)
{
int retval = OK;
if (qf_ptr->qf_type == 1)
{
if (!can_abandon(curbuf, forceit))
{
no_write_message();
retval = FALSE;
}
else
retval = do_ecmd(qf_ptr->qf_fnum, NULL, NULL, NULL, (linenr_T)1,
ECMD_HIDE + ECMD_SET_HELP,
oldwin == curwin ? curwin : NULL);
}
else
{
int old_qf_curlist = qi->qf_curlist;
retval = buflist_getfile(qf_ptr->qf_fnum,
(linenr_T)1, GETF_SETMARK | GETF_SWITCH, forceit);
if (qi != &ql_info && !win_valid_any_tab(oldwin))
{
EMSG(_("E924: Current window was closed"));
*abort = TRUE;
*opened_window = FALSE;
}
else if (old_qf_curlist != qi->qf_curlist
|| !is_qf_entry_present(qi, qf_ptr))
{
if (qi == &ql_info)
EMSG(_("E925: Current quickfix was changed"));
else
EMSG(_("E926: Current location list was changed"));
*abort = TRUE;
}
if (*abort)
retval = FALSE;
}
return retval;
}
static void
qf_jump_goto_line(
linenr_T qf_lnum,
int qf_col,
char_u qf_viscol,
char_u *qf_pattern)
{
linenr_T i;
char_u *line;
colnr_T screen_col;
colnr_T char_col;
if (qf_pattern == NULL)
{
i = qf_lnum;
if (i > 0)
{
if (i > curbuf->b_ml.ml_line_count)
i = curbuf->b_ml.ml_line_count;
curwin->w_cursor.lnum = i;
}
if (qf_col > 0)
{
curwin->w_cursor.col = qf_col - 1;
#ifdef FEAT_VIRTUALEDIT
curwin->w_cursor.coladd = 0;
#endif
if (qf_viscol == TRUE)
{
line = ml_get_curline();
screen_col = 0;
for (char_col = 0; char_col < curwin->w_cursor.col; ++char_col)
{
if (*line == NUL)
break;
if (*line++ == '\t')
{
curwin->w_cursor.col -= 7 - (screen_col % 8);
screen_col += 8 - (screen_col % 8);
}
else
++screen_col;
}
}
check_cursor();
}
else
beginline(BL_WHITE | BL_FIX);
}
else
{
pos_T save_cursor;
save_cursor = curwin->w_cursor;
curwin->w_cursor.lnum = 0;
if (!do_search(NULL, '/', qf_pattern, (long)1,
SEARCH_KEEP, NULL, NULL))
curwin->w_cursor = save_cursor;
}
}
static void
qf_jump_print_msg(
qf_info_T *qi,
int qf_index,
qfline_T *qf_ptr,
buf_T *old_curbuf,
linenr_T old_lnum)
{
linenr_T i;
int len;
if (!msg_scrolled)
update_topline_redraw();
sprintf((char *)IObuff, _("(%d of %d)%s%s: "), qf_index,
qi->qf_lists[qi->qf_curlist].qf_count,
qf_ptr->qf_cleared ? _(" (line deleted)") : "",
(char *)qf_types(qf_ptr->qf_type, qf_ptr->qf_nr));
len = (int)STRLEN(IObuff);
qf_fmt_text(skipwhite(qf_ptr->qf_text), IObuff + len, IOSIZE - len);
i = msg_scroll;
if (curbuf == old_curbuf && curwin->w_cursor.lnum == old_lnum)
msg_scroll = TRUE;
else if (!msg_scrolled && shortmess(SHM_OVERALL))
msg_scroll = FALSE;
msg_attr_keep(IObuff, 0, TRUE);
msg_scroll = i;
}
void
qf_jump(qf_info_T *qi,
int dir,
int errornr,
int forceit)
{
qfline_T *qf_ptr;
qfline_T *old_qf_ptr;
int qf_index;
int old_qf_index;
buf_T *old_curbuf;
linenr_T old_lnum;
char_u *old_swb = p_swb;
unsigned old_swb_flags = swb_flags;
int opened_window = FALSE;
win_T *oldwin = curwin;
int print_message = TRUE;
#ifdef FEAT_FOLDING
int old_KeyTyped = KeyTyped;
#endif
int retval = OK;
if (qi == NULL)
qi = &ql_info;
if (qi->qf_curlist >= qi->qf_listcount
|| qi->qf_lists[qi->qf_curlist].qf_count == 0)
{
EMSG(_(e_quickfix));
return;
}
qf_ptr = qi->qf_lists[qi->qf_curlist].qf_ptr;
old_qf_ptr = qf_ptr;
qf_index = qi->qf_lists[qi->qf_curlist].qf_index;
old_qf_index = qf_index;
if (dir != 0)
{
qf_ptr = get_nth_valid_entry(qi, errornr, qf_ptr, &qf_index, dir);
if (qf_ptr == NULL)
{
qf_ptr = old_qf_ptr;
qf_index = old_qf_index;
goto theend;
}
}
else if (errornr != 0)
qf_ptr = get_nth_entry(qi, errornr, qf_ptr, &qf_index);
qi->qf_lists[qi->qf_curlist].qf_index = qf_index;
if (qf_win_pos_update(qi, old_qf_index))
print_message = FALSE;
if (qf_ptr->qf_type == 1 && (!bt_help(curwin->w_buffer) || cmdmod.tab != 0))
if (jump_to_help_window(qi, &opened_window) == FAIL)
goto theend;
if (bt_quickfix(curbuf) && !opened_window)
{
if (qf_ptr->qf_fnum == 0)
goto theend;
if (qf_jump_to_usable_window(qf_ptr->qf_fnum, &opened_window) == FAIL)
goto failed;
}
old_curbuf = curbuf;
old_lnum = curwin->w_cursor.lnum;
if (qf_ptr->qf_fnum != 0)
{
int abort = FALSE;
retval = qf_jump_edit_buffer(qi, qf_ptr, forceit, oldwin,
&opened_window, &abort);
if (abort)
{
qi = NULL;
qf_ptr = NULL;
}
}
if (retval == OK)
{
if (curbuf == old_curbuf)
setpcmark();
qf_jump_goto_line(qf_ptr->qf_lnum, qf_ptr->qf_col, qf_ptr->qf_viscol,
qf_ptr->qf_pattern);
#ifdef FEAT_FOLDING
if ((fdo_flags & FDO_QUICKFIX) && old_KeyTyped)
foldOpenCursor();
#endif
if (print_message)
qf_jump_print_msg(qi, qf_index, qf_ptr, old_curbuf, old_lnum);
}
else
{
if (opened_window)
win_close(curwin, TRUE);
if (qf_ptr != NULL && qf_ptr->qf_fnum != 0)
{
failed:
qf_ptr = old_qf_ptr;
qf_index = old_qf_index;
}
}
theend:
if (qi != NULL)
{
qi->qf_lists[qi->qf_curlist].qf_ptr = qf_ptr;
qi->qf_lists[qi->qf_curlist].qf_index = qf_index;
}
if (p_swb != old_swb && opened_window)
{
if (p_swb == empty_option)
{
p_swb = old_swb;
swb_flags = old_swb_flags;
}
else
free_string_option(old_swb);
}
}
void
qf_list(exarg_T *eap)
{
buf_T *buf;
char_u *fname;
qfline_T *qfp;
int i;
int idx1 = 1;
int idx2 = -1;
char_u *arg = eap->arg;
int plus = FALSE;
int all = eap->forceit;
qf_info_T *qi = &ql_info;
if (eap->cmdidx == CMD_llist)
{
qi = GET_LOC_LIST(curwin);
if (qi == NULL)
{
EMSG(_(e_loclist));
return;
}
}
if (qi->qf_curlist >= qi->qf_listcount
|| qi->qf_lists[qi->qf_curlist].qf_count == 0)
{
EMSG(_(e_quickfix));
return;
}
if (*arg == '+')
{
++arg;
plus = TRUE;
}
if (!get_list_range(&arg, &idx1, &idx2) || *arg != NUL)
{
EMSG(_(e_trailing));
return;
}
if (plus)
{
i = qi->qf_lists[qi->qf_curlist].qf_index;
idx2 = i + idx1;
idx1 = i;
}
else
{
i = qi->qf_lists[qi->qf_curlist].qf_count;
if (idx1 < 0)
idx1 = (-idx1 > i) ? 0 : idx1 + i + 1;
if (idx2 < 0)
idx2 = (-idx2 > i) ? 0 : idx2 + i + 1;
}
if (qi->qf_lists[qi->qf_curlist].qf_nonevalid)
all = TRUE;
qfp = qi->qf_lists[qi->qf_curlist].qf_start;
for (i = 1; !got_int && i <= qi->qf_lists[qi->qf_curlist].qf_count; )
{
if ((qfp->qf_valid || all) && idx1 <= i && i <= idx2)
{
msg_putchar('\n');
if (got_int)
break;
fname = NULL;
if (qfp->qf_fnum != 0
&& (buf = buflist_findnr(qfp->qf_fnum)) != NULL)
{
fname = buf->b_fname;
if (qfp->qf_type == 1)
fname = gettail(fname);
}
if (fname == NULL)
sprintf((char *)IObuff, "%2d", i);
else
vim_snprintf((char *)IObuff, IOSIZE, "%2d %s",
i, (char *)fname);
msg_outtrans_attr(IObuff, i == qi->qf_lists[qi->qf_curlist].qf_index
? HL_ATTR(HLF_QFL) : HL_ATTR(HLF_D));
if (qfp->qf_lnum == 0)
IObuff[0] = NUL;
else if (qfp->qf_col == 0)
sprintf((char *)IObuff, ":%ld", qfp->qf_lnum);
else
sprintf((char *)IObuff, ":%ld col %d",
qfp->qf_lnum, qfp->qf_col);
sprintf((char *)IObuff + STRLEN(IObuff), "%s:",
(char *)qf_types(qfp->qf_type, qfp->qf_nr));
msg_puts_attr(IObuff, HL_ATTR(HLF_N));
if (qfp->qf_pattern != NULL)
{
qf_fmt_text(qfp->qf_pattern, IObuff, IOSIZE);
STRCAT(IObuff, ":");
msg_puts(IObuff);
}
msg_puts((char_u *)" ");
qf_fmt_text((fname != NULL || qfp->qf_lnum != 0)
? skipwhite(qfp->qf_text) : qfp->qf_text,
IObuff, IOSIZE);
msg_prt_line(IObuff, FALSE);
out_flush();
}
qfp = qfp->qf_next;
if (qfp == NULL)
break;
++i;
ui_breakcheck();
}
}
static void
qf_fmt_text(char_u *text, char_u *buf, int bufsize)
{
int i;
char_u *p = text;
for (i = 0; *p != NUL && i < bufsize - 1; ++i)
{
if (*p == '\n')
{
buf[i] = ' ';
while (*++p != NUL)
if (!VIM_ISWHITE(*p) && *p != '\n')
break;
}
else
buf[i] = *p++;
}
buf[i] = NUL;
}
static void
qf_msg(qf_info_T *qi, int which, char *lead)
{
char *title = (char *)qi->qf_lists[which].qf_title;
int count = qi->qf_lists[which].qf_count;
char_u buf[IOSIZE];
vim_snprintf((char *)buf, IOSIZE, _("%serror list %d of %d; %d errors "),
lead,
which + 1,
qi->qf_listcount,
count);
if (title != NULL)
{
size_t len = STRLEN(buf);
if (len < 34)
{
vim_memset(buf + len, ' ', 34 - len);
buf[34] = NUL;
}
vim_strcat(buf, (char_u *)title, IOSIZE);
}
trunc_string(buf, buf, Columns - 1, IOSIZE);
msg(buf);
}
void
qf_age(exarg_T *eap)
{
qf_info_T *qi = &ql_info;
int count;
if (eap->cmdidx == CMD_lolder || eap->cmdidx == CMD_lnewer)
{
qi = GET_LOC_LIST(curwin);
if (qi == NULL)
{
EMSG(_(e_loclist));
return;
}
}
if (eap->addr_count != 0)
count = eap->line2;
else
count = 1;
while (count--)
{
if (eap->cmdidx == CMD_colder || eap->cmdidx == CMD_lolder)
{
if (qi->qf_curlist == 0)
{
EMSG(_("E380: At bottom of quickfix stack"));
break;
}
--qi->qf_curlist;
}
else
{
if (qi->qf_curlist >= qi->qf_listcount - 1)
{
EMSG(_("E381: At top of quickfix stack"));
break;
}
++qi->qf_curlist;
}
}
qf_msg(qi, qi->qf_curlist, "");
qf_update_buffer(qi, NULL);
}
void
qf_history(exarg_T *eap)
{
qf_info_T *qi = &ql_info;
int i;
if (eap->cmdidx == CMD_lhistory)
qi = GET_LOC_LIST(curwin);
if (qi == NULL || (qi->qf_listcount == 0
&& qi->qf_lists[qi->qf_curlist].qf_count == 0))
MSG(_("No entries"));
else
for (i = 0; i < qi->qf_listcount; ++i)
qf_msg(qi, i, i == qi->qf_curlist ? "> " : " ");
}
static void
qf_free_items(qf_info_T *qi, int idx)
{
qfline_T *qfp;
qfline_T *qfpnext;
int stop = FALSE;
qf_list_T *qfl = &qi->qf_lists[idx];
while (qfl->qf_count && qfl->qf_start != NULL)
{
qfp = qfl->qf_start;
qfpnext = qfp->qf_next;
if (!stop)
{
vim_free(qfp->qf_text);
stop = (qfp == qfpnext);
vim_free(qfp->qf_pattern);
vim_free(qfp);
if (stop)
qfl->qf_count = 1;
}
qfl->qf_start = qfpnext;
--qfl->qf_count;
}
qfl->qf_index = 0;
qfl->qf_start = NULL;
qfl->qf_last = NULL;
qfl->qf_ptr = NULL;
qfl->qf_nonevalid = TRUE;
qf_clean_dir_stack(&qfl->qf_dir_stack);
qfl->qf_directory = NULL;
qf_clean_dir_stack(&qfl->qf_file_stack);
qfl->qf_currfile = NULL;
qfl->qf_multiline = FALSE;
qfl->qf_multiignore = FALSE;
qfl->qf_multiscan = FALSE;
}
static void
qf_free(qf_info_T *qi, int idx)
{
qf_list_T *qfl = &qi->qf_lists[idx];
qf_free_items(qi, idx);
vim_free(qfl->qf_title);
qfl->qf_title = NULL;
free_tv(qfl->qf_ctx);
qfl->qf_ctx = NULL;
qfl->qf_id = 0;
}
void
qf_mark_adjust(
win_T *wp,
linenr_T line1,
linenr_T line2,
long amount,
long amount_after)
{
int i;
qfline_T *qfp;
int idx;
qf_info_T *qi = &ql_info;
int found_one = FALSE;
int buf_has_flag = wp == NULL ? BUF_HAS_QF_ENTRY : BUF_HAS_LL_ENTRY;
if (!(curbuf->b_has_qf_entry & buf_has_flag))
return;
if (wp != NULL)
{
if (wp->w_llist == NULL)
return;
qi = wp->w_llist;
}
for (idx = 0; idx < qi->qf_listcount; ++idx)
if (qi->qf_lists[idx].qf_count)
for (i = 0, qfp = qi->qf_lists[idx].qf_start;
i < qi->qf_lists[idx].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)
{
if (amount == MAXLNUM)
qfp->qf_cleared = TRUE;
else
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;
}
static char_u *
qf_types(int c, int nr)
{
static char_u buf[20];
static char_u cc[3];
char_u *p;
if (c == 'W' || c == 'w')
p = (char_u *)" warning";
else if (c == 'I' || c == 'i')
p = (char_u *)" info";
else if (c == 'E' || c == 'e' || (c == 0 && nr > 0))
p = (char_u *)" error";
else if (c == 0 || c == 1)
p = (char_u *)"";
else
{
cc[0] = ' ';
cc[1] = c;
cc[2] = NUL;
p = cc;
}
if (nr <= 0)
return p;
sprintf((char *)buf, "%s %3d", (char *)p, nr);
return buf;
}
void
ex_cwindow(exarg_T *eap)
{
qf_info_T *qi = &ql_info;
win_T *win;
if (eap->cmdidx == CMD_lwindow)
{
qi = GET_LOC_LIST(curwin);
if (qi == NULL)
return;
}
win = qf_find_win(qi);
if (qi->qf_lists[qi->qf_curlist].qf_nonevalid
|| qi->qf_lists[qi->qf_curlist].qf_count == 0
|| qi->qf_curlist >= qi->qf_listcount)
{
if (win != NULL)
ex_cclose(eap);
}
else if (win == NULL)
ex_copen(eap);
}
void
ex_cclose(exarg_T *eap)
{
win_T *win = NULL;
qf_info_T *qi = &ql_info;
if (eap->cmdidx == CMD_lclose || eap->cmdidx == CMD_lwindow)
{
qi = GET_LOC_LIST(curwin);
if (qi == NULL)
return;
}
win = qf_find_win(qi);
if (win != NULL)
win_close(win, FALSE);
}
void
ex_copen(exarg_T *eap)
{
qf_info_T *qi = &ql_info;
int height;
win_T *win;
tabpage_T *prevtab = curtab;
buf_T *qf_buf;
win_T *oldwin = curwin;
if (eap->cmdidx == CMD_lopen || eap->cmdidx == CMD_lwindow)
{
qi = GET_LOC_LIST(curwin);
if (qi == NULL)
{
EMSG(_(e_loclist));
return;
}
}
if (eap->addr_count != 0)
height = eap->line2;
else
height = QF_WINHEIGHT;
reset_VIsual_and_resel();
#ifdef FEAT_GUI
need_mouse_correct = TRUE;
#endif
win = qf_find_win(qi);
if (win != NULL && cmdmod.tab == 0)
{
win_goto(win);
if (eap->addr_count != 0)
{
if (cmdmod.split & WSP_VERT)
{
if (height != win->w_width)
win_setwidth(height);
}
else if (height != win->w_height)
win_setheight(height);
}
}
else
{
qf_buf = qf_find_buf(qi);
win = curwin;
if ((eap->cmdidx == CMD_copen || eap->cmdidx == CMD_cwindow)
&& cmdmod.split == 0)
win_goto(lastwin);
if (win_split(height, WSP_BELOW | WSP_NEWLOC) == FAIL)
return;
RESET_BINDING(curwin);
if (eap->cmdidx == CMD_lopen || eap->cmdidx == CMD_lwindow)
{
curwin->w_llist_ref = win->w_llist;
win->w_llist->qf_refcount++;
}
if (oldwin != curwin)
oldwin = NULL;
if (qf_buf != NULL)
(void)do_ecmd(qf_buf->b_fnum, NULL, NULL, NULL, ECMD_ONE,
ECMD_HIDE + ECMD_OLDBUF, oldwin);
else
{
(void)do_ecmd(0, NULL, NULL, NULL, ECMD_ONE, ECMD_HIDE, oldwin);
set_option_value((char_u *)"swf", 0L, NULL, OPT_LOCAL);
set_option_value((char_u *)"bt", 0L, (char_u *)"quickfix",
OPT_LOCAL);
set_option_value((char_u *)"bh", 0L, (char_u *)"wipe", OPT_LOCAL);
RESET_BINDING(curwin);
#ifdef FEAT_DIFF
curwin->w_p_diff = FALSE;
#endif
#ifdef FEAT_FOLDING
set_option_value((char_u *)"fdm", 0L, (char_u *)"manual",
OPT_LOCAL);
#endif
}
if (curtab == prevtab && curwin->w_width == Columns)
win_setheight(height);
curwin->w_p_wfh = TRUE;
if (win_valid(win))
prevwin = win;
}
qf_set_title_var(qi);
qf_fill_buffer(qi, curbuf, NULL);
curwin->w_cursor.lnum = qi->qf_lists[qi->qf_curlist].qf_index;
curwin->w_cursor.col = 0;
check_cursor();
update_topline();
}
static void
qf_win_goto(win_T *win, linenr_T lnum)
{
win_T *old_curwin = curwin;
curwin = win;
curbuf = win->w_buffer;
curwin->w_cursor.lnum = lnum;
curwin->w_cursor.col = 0;
#ifdef FEAT_VIRTUALEDIT
curwin->w_cursor.coladd = 0;
#endif
curwin->w_curswant = 0;
update_topline();
redraw_later(VALID);
curwin->w_redr_status = TRUE;
curwin = old_curwin;
curbuf = curwin->w_buffer;
}
void
ex_cbottom(exarg_T *eap UNUSED)
{
qf_info_T *qi = &ql_info;
win_T *win;
if (eap->cmdidx == CMD_lbottom)
{
qi = GET_LOC_LIST(curwin);
if (qi == NULL)
{
EMSG(_(e_loclist));
return;
}
}
win = qf_find_win(qi);
if (win != NULL && win->w_cursor.lnum != win->w_buffer->b_ml.ml_line_count)
qf_win_goto(win, win->w_buffer->b_ml.ml_line_count);
}
linenr_T
qf_current_entry(win_T *wp)
{
qf_info_T *qi = &ql_info;
if (IS_LL_WINDOW(wp))
qi = wp->w_llist_ref;
return qi->qf_lists[qi->qf_curlist].qf_index;
}
static int
qf_win_pos_update(
qf_info_T *qi,
int old_qf_index)
{
win_T *win;
int qf_index = qi->qf_lists[qi->qf_curlist].qf_index;
win = qf_find_win(qi);
if (win != NULL
&& qf_index <= win->w_buffer->b_ml.ml_line_count
&& old_qf_index != qf_index)
{
if (qf_index > old_qf_index)
{
win->w_redraw_top = old_qf_index;
win->w_redraw_bot = qf_index;
}
else
{
win->w_redraw_top = qf_index;
win->w_redraw_bot = old_qf_index;
}
qf_win_goto(win, qf_index);
}
return win != NULL;
}
static int
is_qf_win(win_T *win, qf_info_T *qi)
{
if (bt_quickfix(win->w_buffer))
if ((qi == &ql_info && win->w_llist_ref == NULL)
|| (qi != &ql_info && win->w_llist_ref == qi))
return TRUE;
return FALSE;
}
static win_T *
qf_find_win(qf_info_T *qi)
{
win_T *win;
FOR_ALL_WINDOWS(win)
if (is_qf_win(win, qi))
break;
return win;
}
static buf_T *
qf_find_buf(qf_info_T *qi)
{
tabpage_T *tp;
win_T *win;
FOR_ALL_TAB_WINDOWS(tp, win)
if (is_qf_win(win, qi))
return win->w_buffer;
return NULL;
}
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;
}
}
static void
qf_update_buffer(qf_info_T *qi, qfline_T *old_last)
{
buf_T *buf;
win_T *win;
aco_save_T aco;
buf = qf_find_buf(qi);
if (buf != NULL)
{
linenr_T old_line_count = buf->b_ml.ml_line_count;
if (old_last == NULL)
aucmd_prepbuf(&aco, buf);
qf_update_win_titlevar(qi);
qf_fill_buffer(qi, buf, old_last);
++CHANGEDTICK(buf);
if (old_last == NULL)
{
(void)qf_win_pos_update(qi, 0);
aucmd_restbuf(&aco);
}
if ((win = qf_find_win(qi)) != NULL && old_line_count < win->w_botline)
redraw_buf_later(buf, NOT_VALID);
}
}
static void
qf_set_title_var(qf_info_T *qi)
{
if (qi->qf_lists[qi->qf_curlist].qf_title != NULL)
set_internal_string_var((char_u *)"w:quickfix_title",
qi->qf_lists[qi->qf_curlist].qf_title);
}
static void
qf_fill_buffer(qf_info_T *qi, buf_T *buf, qfline_T *old_last)
{
linenr_T lnum;
qfline_T *qfp;
buf_T *errbuf;
int len;
int old_KeyTyped = KeyTyped;
if (old_last == NULL)
{
if (buf != curbuf)
{
internal_error("qf_fill_buffer()");
return;
}
while ((curbuf->b_ml.ml_flags & ML_EMPTY) == 0)
(void)ml_delete((linenr_T)1, FALSE);
}
if (qi->qf_curlist < qi->qf_listcount)
{
if (old_last == NULL)
{
qfp = qi->qf_lists[qi->qf_curlist].qf_start;
lnum = 0;
}
else
{
qfp = old_last->qf_next;
lnum = buf->b_ml.ml_line_count;
}
while (lnum < qi->qf_lists[qi->qf_curlist].qf_count)
{
if (qfp->qf_fnum != 0
&& (errbuf = buflist_findnr(qfp->qf_fnum)) != NULL
&& errbuf->b_fname != NULL)
{
if (qfp->qf_type == 1)
STRCPY(IObuff, gettail(errbuf->b_fname));
else
STRCPY(IObuff, errbuf->b_fname);
len = (int)STRLEN(IObuff);
}
else
len = 0;
IObuff[len++] = '|';
if (qfp->qf_lnum > 0)
{
sprintf((char *)IObuff + len, "%ld", qfp->qf_lnum);
len += (int)STRLEN(IObuff + len);
if (qfp->qf_col > 0)
{
sprintf((char *)IObuff + len, " col %d", qfp->qf_col);
len += (int)STRLEN(IObuff + len);
}
sprintf((char *)IObuff + len, "%s",
(char *)qf_types(qfp->qf_type, qfp->qf_nr));
len += (int)STRLEN(IObuff + len);
}
else if (qfp->qf_pattern != NULL)
{
qf_fmt_text(qfp->qf_pattern, IObuff + len, IOSIZE - len);
len += (int)STRLEN(IObuff + len);
}
IObuff[len++] = '|';
IObuff[len++] = ' ';
qf_fmt_text(len > 3 ? skipwhite(qfp->qf_text) : qfp->qf_text,
IObuff + len, IOSIZE - len);
if (ml_append_buf(buf, lnum, IObuff,
(colnr_T)STRLEN(IObuff) + 1, FALSE) == FAIL)
break;
++lnum;
qfp = qfp->qf_next;
if (qfp == NULL)
break;
}
if (old_last == NULL)
(void)ml_delete(lnum + 1, FALSE);
}
check_lnums(TRUE);
if (old_last == NULL)
{
#ifdef FEAT_AUTOCMD
++curbuf_lock;
#endif
set_option_value((char_u *)"ft", 0L, (char_u *)"qf", OPT_LOCAL);
curbuf->b_p_ma = FALSE;
#ifdef FEAT_AUTOCMD
keep_filetype = TRUE;
apply_autocmds(EVENT_BUFREADPOST, (char_u *)"quickfix", NULL,
FALSE, curbuf);
apply_autocmds(EVENT_BUFWINENTER, (char_u *)"quickfix", NULL,
FALSE, curbuf);
keep_filetype = FALSE;
--curbuf_lock;
#endif
redraw_curbuf_later(NOT_VALID);
}
KeyTyped = old_KeyTyped;
}
int
grep_internal(cmdidx_T cmdidx)
{
return ((cmdidx == CMD_grep
|| cmdidx == CMD_lgrep
|| cmdidx == CMD_grepadd
|| cmdidx == CMD_lgrepadd)
&& STRCMP("internal",
*curbuf->b_p_gp == NUL ? p_gp : curbuf->b_p_gp) == 0);
}
void
ex_make(exarg_T *eap)
{
char_u *fname;
char_u *cmd;
char_u *enc = NULL;
unsigned len;
win_T *wp = NULL;
qf_info_T *qi = &ql_info;
int res;
#ifdef FEAT_AUTOCMD
char_u *au_name = NULL;
if (grep_internal(eap->cmdidx))
{
ex_vimgrep(eap);
return;
}
switch (eap->cmdidx)
{
case CMD_make: au_name = (char_u *)"make"; break;
case CMD_lmake: au_name = (char_u *)"lmake"; break;
case CMD_grep: au_name = (char_u *)"grep"; break;
case CMD_lgrep: au_name = (char_u *)"lgrep"; break;
case CMD_grepadd: au_name = (char_u *)"grepadd"; break;
case CMD_lgrepadd: au_name = (char_u *)"lgrepadd"; break;
default: break;
}
if (au_name != NULL && apply_autocmds(EVENT_QUICKFIXCMDPRE, au_name,
curbuf->b_fname, TRUE, curbuf))
{
# ifdef FEAT_EVAL
if (aborting())
return;
# endif
}
#endif
#ifdef FEAT_MBYTE
enc = (*curbuf->b_p_menc != NUL) ? curbuf->b_p_menc : p_menc;
#endif
if (eap->cmdidx == CMD_lmake || eap->cmdidx == CMD_lgrep
|| eap->cmdidx == CMD_lgrepadd)
wp = curwin;
autowrite_all();
fname = get_mef_name();
if (fname == NULL)
return;
mch_remove(fname);
len = (unsigned)STRLEN(p_shq) * 2 + (unsigned)STRLEN(eap->arg) + 1;
if (*p_sp != NUL)
len += (unsigned)STRLEN(p_sp) + (unsigned)STRLEN(fname) + 3;
cmd = alloc(len);
if (cmd == NULL)
return;
sprintf((char *)cmd, "%s%s%s", (char *)p_shq, (char *)eap->arg,
(char *)p_shq);
if (*p_sp != NUL)
append_redir(cmd, len, p_sp, fname);
if (msg_col == 0)
msg_didout = FALSE;
msg_start();
MSG_PUTS(":!");
msg_outtrans(cmd);
do_shell(cmd, *p_sp != NUL ? SHELL_DOOUT : 0);
#ifdef AMIGA
out_flush();
(void)char_avail();
#endif
res = qf_init(wp, fname, (eap->cmdidx != CMD_make
&& eap->cmdidx != CMD_lmake) ? p_gefm : p_efm,
(eap->cmdidx != CMD_grepadd
&& eap->cmdidx != CMD_lgrepadd),
*eap->cmdlinep, enc);
if (wp != NULL)
qi = GET_LOC_LIST(wp);
#ifdef FEAT_AUTOCMD
if (au_name != NULL)
{
apply_autocmds(EVENT_QUICKFIXCMDPOST, au_name,
curbuf->b_fname, TRUE, curbuf);
if (qi->qf_curlist < qi->qf_listcount)
res = qi->qf_lists[qi->qf_curlist].qf_count;
else
res = 0;
}
#endif
if (res > 0 && !eap->forceit)
qf_jump(qi, 0, 0, FALSE);
mch_remove(fname);
vim_free(fname);
vim_free(cmd);
}
static char_u *
get_mef_name(void)
{
char_u *p;
char_u *name;
static int start = -1;
static int off = 0;
#ifdef HAVE_LSTAT
stat_T sb;
#endif
if (*p_mef == NUL)
{
name = vim_tempname('e', FALSE);
if (name == NULL)
EMSG(_(e_notmp));
return name;
}
for (p = p_mef; *p; ++p)
if (p[0] == '#' && p[1] == '#')
break;
if (*p == NUL)
return vim_strsave(p_mef);
for (;;)
{
if (start == -1)
start = mch_get_pid();
else
off += 19;
name = alloc((unsigned)STRLEN(p_mef) + 30);
if (name == NULL)
break;
STRCPY(name, p_mef);
sprintf((char *)name + (p - p_mef), "%d%d", start, off);
STRCAT(name, p + 2);
if (mch_getperm(name) < 0
#ifdef HAVE_LSTAT
&& mch_lstat((char *)name, &sb) < 0
#endif
)
break;
vim_free(name);
}
return name;
}
int
qf_get_size(exarg_T *eap)
{
qf_info_T *qi = &ql_info;
qfline_T *qfp;
int i, sz = 0;
int prev_fnum = 0;
if (eap->cmdidx == CMD_ldo || eap->cmdidx == CMD_lfdo)
{
qi = GET_LOC_LIST(curwin);
if (qi == NULL)
return 0;
}
for (i = 0, qfp = qi->qf_lists[qi->qf_curlist].qf_start;
i < qi->qf_lists[qi->qf_curlist].qf_count && qfp != NULL;
++i, qfp = qfp->qf_next)
{
if (qfp->qf_valid)
{
if (eap->cmdidx == CMD_cdo || eap->cmdidx == CMD_ldo)
sz++;
else if (qfp->qf_fnum > 0 && qfp->qf_fnum != prev_fnum)
{
sz++;
prev_fnum = qfp->qf_fnum;
}
}
}
return sz;
}
int
qf_get_cur_idx(exarg_T *eap)
{
qf_info_T *qi = &ql_info;
if (eap->cmdidx == CMD_ldo || eap->cmdidx == CMD_lfdo)
{
qi = GET_LOC_LIST(curwin);
if (qi == NULL)
return 0;
}
return qi->qf_lists[qi->qf_curlist].qf_index;
}
int
qf_get_cur_valid_idx(exarg_T *eap)
{
qf_info_T *qi = &ql_info;
qf_list_T *qfl;
qfline_T *qfp;
int i, eidx = 0;
int prev_fnum = 0;
if (eap->cmdidx == CMD_ldo || eap->cmdidx == CMD_lfdo)
{
qi = GET_LOC_LIST(curwin);
if (qi == NULL)
return 1;
}
qfl = &qi->qf_lists[qi->qf_curlist];
qfp = qfl->qf_start;
if (qfl->qf_count <= 0 || qfl->qf_nonevalid)
return 1;
for (i = 1; i <= qfl->qf_index && qfp!= NULL; i++, qfp = qfp->qf_next)
{
if (qfp->qf_valid)
{
if (eap->cmdidx == CMD_cfdo || eap->cmdidx == CMD_lfdo)
{
if (qfp->qf_fnum > 0 && qfp->qf_fnum != prev_fnum)
{
eidx++;
prev_fnum = qfp->qf_fnum;
}
}
else
eidx++;
}
}
return eidx ? eidx : 1;
}
static int
qf_get_nth_valid_entry(qf_info_T *qi, int n, int fdo)
{
qf_list_T *qfl = &qi->qf_lists[qi->qf_curlist];
qfline_T *qfp = qfl->qf_start;
int i, eidx;
int prev_fnum = 0;
if (qfl->qf_count <= 0 || qfl->qf_nonevalid)
return 1;
for (i = 1, eidx = 0; i <= qfl->qf_count && qfp != NULL;
i++, qfp = qfp->qf_next)
{
if (qfp->qf_valid)
{
if (fdo)
{
if (qfp->qf_fnum > 0 && qfp->qf_fnum != prev_fnum)
{
eidx++;
prev_fnum = qfp->qf_fnum;
}
}
else
eidx++;
}
if (eidx == n)
break;
}
if (i <= qfl->qf_count)
return i;
else
return 1;
}
void
ex_cc(exarg_T *eap)
{
qf_info_T *qi = &ql_info;
int errornr;
if (eap->cmdidx == CMD_ll
|| eap->cmdidx == CMD_lrewind
|| eap->cmdidx == CMD_lfirst
|| eap->cmdidx == CMD_llast
|| eap->cmdidx == CMD_ldo
|| eap->cmdidx == CMD_lfdo)
{
qi = GET_LOC_LIST(curwin);
if (qi == NULL)
{
EMSG(_(e_loclist));
return;
}
}
if (eap->addr_count > 0)
errornr = (int)eap->line2;
else
{
if (eap->cmdidx == CMD_cc || eap->cmdidx == CMD_ll)
errornr = 0;
else if (eap->cmdidx == CMD_crewind || eap->cmdidx == CMD_lrewind
|| eap->cmdidx == CMD_cfirst || eap->cmdidx == CMD_lfirst)
errornr = 1;
else
errornr = 32767;
}
if (eap->cmdidx == CMD_cdo || eap->cmdidx == CMD_ldo
|| eap->cmdidx == CMD_cfdo || eap->cmdidx == CMD_lfdo)
errornr = qf_get_nth_valid_entry(qi,
eap->addr_count > 0 ? (int)eap->line1 : 1,
eap->cmdidx == CMD_cfdo || eap->cmdidx == CMD_lfdo);
qf_jump(qi, 0, errornr, eap->forceit);
}
void
ex_cnext(exarg_T *eap)
{
qf_info_T *qi = &ql_info;
int errornr;
if (eap->cmdidx == CMD_lnext
|| eap->cmdidx == CMD_lNext
|| eap->cmdidx == CMD_lprevious
|| eap->cmdidx == CMD_lnfile
|| eap->cmdidx == CMD_lNfile
|| eap->cmdidx == CMD_lpfile
|| eap->cmdidx == CMD_ldo
|| eap->cmdidx == CMD_lfdo)
{
qi = GET_LOC_LIST(curwin);
if (qi == NULL)
{
EMSG(_(e_loclist));
return;
}
}
if (eap->addr_count > 0
&& (eap->cmdidx != CMD_cdo && eap->cmdidx != CMD_ldo
&& eap->cmdidx != CMD_cfdo && eap->cmdidx != CMD_lfdo))
errornr = (int)eap->line2;
else
errornr = 1;
qf_jump(qi, (eap->cmdidx == CMD_cnext || eap->cmdidx == CMD_lnext
|| eap->cmdidx == CMD_cdo || eap->cmdidx == CMD_ldo)
? FORWARD
: (eap->cmdidx == CMD_cnfile || eap->cmdidx == CMD_lnfile
|| eap->cmdidx == CMD_cfdo || eap->cmdidx == CMD_lfdo)
? FORWARD_FILE
: (eap->cmdidx == CMD_cpfile || eap->cmdidx == CMD_lpfile
|| eap->cmdidx == CMD_cNfile || eap->cmdidx == CMD_lNfile)
? BACKWARD_FILE
: BACKWARD,
errornr, eap->forceit);
}
void
ex_cfile(exarg_T *eap)
{
char_u *enc = NULL;
win_T *wp = NULL;
qf_info_T *qi = &ql_info;
#ifdef FEAT_AUTOCMD
char_u *au_name = NULL;
#endif
if (eap->cmdidx == CMD_lfile || eap->cmdidx == CMD_lgetfile
|| eap->cmdidx == CMD_laddfile)
wp = curwin;
#ifdef FEAT_AUTOCMD
switch (eap->cmdidx)
{
case CMD_cfile: au_name = (char_u *)"cfile"; break;
case CMD_cgetfile: au_name = (char_u *)"cgetfile"; break;
case CMD_caddfile: au_name = (char_u *)"caddfile"; break;
case CMD_lfile: au_name = (char_u *)"lfile"; break;
case CMD_lgetfile: au_name = (char_u *)"lgetfile"; break;
case CMD_laddfile: au_name = (char_u *)"laddfile"; break;
default: break;
}
if (au_name != NULL)
apply_autocmds(EVENT_QUICKFIXCMDPRE, au_name, NULL, FALSE, curbuf);
#endif
#ifdef FEAT_MBYTE
enc = (*curbuf->b_p_menc != NUL) ? curbuf->b_p_menc : p_menc;
#endif
#ifdef FEAT_BROWSE
if (cmdmod.browse)
{
char_u *browse_file = do_browse(0, (char_u *)_("Error file"), eap->arg,
NULL, NULL, BROWSE_FILTER_ALL_FILES, NULL);
if (browse_file == NULL)
return;
set_string_option_direct((char_u *)"ef", -1, browse_file, OPT_FREE, 0);
vim_free(browse_file);
}
else
#endif
if (*eap->arg != NUL)
set_string_option_direct((char_u *)"ef", -1, eap->arg, OPT_FREE, 0);
if (qf_init(wp, p_ef, p_efm, (eap->cmdidx != CMD_caddfile
&& eap->cmdidx != CMD_laddfile),
*eap->cmdlinep, enc) > 0
&& (eap->cmdidx == CMD_cfile
|| eap->cmdidx == CMD_lfile))
{
#ifdef FEAT_AUTOCMD
if (au_name != NULL)
apply_autocmds(EVENT_QUICKFIXCMDPOST, au_name, NULL, FALSE, curbuf);
#endif
if (wp != NULL)
qi = GET_LOC_LIST(wp);
qf_jump(qi, 0, 0, eap->forceit);
}
else
{
#ifdef FEAT_AUTOCMD
if (au_name != NULL)
apply_autocmds(EVENT_QUICKFIXCMDPOST, au_name, NULL, FALSE, curbuf);
#endif
}
}
void
ex_vimgrep(exarg_T *eap)
{
regmmatch_T regmatch;
int fcount;
char_u **fnames;
char_u *fname;
char_u *title;
char_u *s;
char_u *p;
int fi;
qf_info_T *qi = &ql_info;
#ifdef FEAT_AUTOCMD
qfline_T *cur_qf_start;
#endif
long lnum;
buf_T *buf;
int duplicate_name = FALSE;
int using_dummy;
int redraw_for_dummy = FALSE;
int found_match;
buf_T *first_match_buf = NULL;
time_t seconds = 0;
int save_mls;
#if defined(FEAT_AUTOCMD) && defined(FEAT_SYN_HL)
char_u *save_ei = NULL;
#endif
aco_save_T aco;
int flags = 0;
colnr_T col;
long tomatch;
char_u *dirname_start = NULL;
char_u *dirname_now = NULL;
char_u *target_dir = NULL;
#ifdef FEAT_AUTOCMD
char_u *au_name = NULL;
switch (eap->cmdidx)
{
case CMD_vimgrep: au_name = (char_u *)"vimgrep"; break;
case CMD_lvimgrep: au_name = (char_u *)"lvimgrep"; break;
case CMD_vimgrepadd: au_name = (char_u *)"vimgrepadd"; break;
case CMD_lvimgrepadd: au_name = (char_u *)"lvimgrepadd"; break;
case CMD_grep: au_name = (char_u *)"grep"; break;
case CMD_lgrep: au_name = (char_u *)"lgrep"; break;
case CMD_grepadd: au_name = (char_u *)"grepadd"; break;
case CMD_lgrepadd: au_name = (char_u *)"lgrepadd"; break;
default: break;
}
if (au_name != NULL && apply_autocmds(EVENT_QUICKFIXCMDPRE, au_name,
curbuf->b_fname, TRUE, curbuf))
{
# ifdef FEAT_EVAL
if (aborting())
return;
# endif
}
#endif
if (eap->cmdidx == CMD_lgrep
|| eap->cmdidx == CMD_lvimgrep
|| eap->cmdidx == CMD_lgrepadd
|| eap->cmdidx == CMD_lvimgrepadd)
{
qi = ll_get_or_alloc_list(curwin);
if (qi == NULL)
return;
}
if (eap->addr_count > 0)
tomatch = eap->line2;
else
tomatch = MAXLNUM;
regmatch.regprog = NULL;
title = vim_strsave(*eap->cmdlinep);
p = skip_vimgrep_pat(eap->arg, &s, &flags);
if (p == NULL)
{
EMSG(_(e_invalpat));
goto theend;
}
if (s != NULL && *s == NUL)
{
if (last_search_pat() == NULL)
{
EMSG(_(e_noprevre));
goto theend;
}
regmatch.regprog = vim_regcomp(last_search_pat(), RE_MAGIC);
}
else
regmatch.regprog = vim_regcomp(s, RE_MAGIC);
if (regmatch.regprog == NULL)
goto theend;
regmatch.rmm_ic = p_ic;
regmatch.rmm_maxcol = 0;
p = skipwhite(p);
if (*p == NUL)
{
EMSG(_("E683: File name missing or invalid pattern"));
goto theend;
}
if ((eap->cmdidx != CMD_grepadd && eap->cmdidx != CMD_lgrepadd
&& eap->cmdidx != CMD_vimgrepadd && eap->cmdidx != CMD_lvimgrepadd)
|| qi->qf_curlist == qi->qf_listcount)
qf_new_list(qi, title != NULL ? title : *eap->cmdlinep);
if (get_arglist_exp(p, &fcount, &fnames, TRUE) == FAIL)
goto theend;
if (fcount == 0)
{
EMSG(_(e_nomatch));
goto theend;
}
dirname_start = alloc_id(MAXPATHL, aid_qf_dirname_start);
dirname_now = alloc_id(MAXPATHL, aid_qf_dirname_now);
if (dirname_start == NULL || dirname_now == NULL)
{
FreeWild(fcount, fnames);
goto theend;
}
mch_dirname(dirname_start, MAXPATHL);
#ifdef FEAT_AUTOCMD
cur_qf_start = qi->qf_lists[qi->qf_curlist].qf_start;
#endif
seconds = (time_t)0;
for (fi = 0; fi < fcount && !got_int && tomatch > 0; ++fi)
{
fname = shorten_fname1(fnames[fi]);
if (time(NULL) > seconds)
{
seconds = time(NULL);
msg_start();
p = msg_strtrunc(fname, TRUE);
if (p == NULL)
msg_outtrans(fname);
else
{
msg_outtrans(p);
vim_free(p);
}
msg_clr_eos();
msg_didout = FALSE;
msg_nowait = TRUE;
msg_col = 0;
out_flush();
}
buf = buflist_findname_exp(fnames[fi]);
if (buf == NULL || buf->b_ml.ml_mfp == NULL)
{
duplicate_name = (buf != NULL);
using_dummy = TRUE;
redraw_for_dummy = TRUE;
#if defined(FEAT_AUTOCMD) && defined(FEAT_SYN_HL)
save_ei = au_event_disable(",Filetype");
#endif
save_mls = p_mls;
p_mls = 0;
buf = load_dummy_buffer(fname, dirname_start, dirname_now);
p_mls = save_mls;
#if defined(FEAT_AUTOCMD) && defined(FEAT_SYN_HL)
au_event_restore(save_ei);
#endif
}
else
using_dummy = FALSE;
#ifdef FEAT_AUTOCMD
if (cur_qf_start != qi->qf_lists[qi->qf_curlist].qf_start)
{
int idx;
for (idx = 0; idx < LISTCOUNT; ++idx)
if (cur_qf_start == qi->qf_lists[idx].qf_start)
{
qi->qf_curlist = idx;
break;
}
if (idx == LISTCOUNT)
{
qf_new_list(qi, *eap->cmdlinep);
cur_qf_start = qi->qf_lists[qi->qf_curlist].qf_start;
}
}
#endif
if (buf == NULL)
{
if (!got_int)
smsg((char_u *)_("Cannot open file \"%s\""), fname);
}
else
{
found_match = FALSE;
for (lnum = 1; lnum <= buf->b_ml.ml_line_count && tomatch > 0;
++lnum)
{
col = 0;
while (vim_regexec_multi(®match, curwin, buf, lnum,
col, NULL, NULL) > 0)
{
if (qf_add_entry(qi,
qi->qf_curlist,
NULL,
fname,
duplicate_name ? 0 : buf->b_fnum,
ml_get_buf(buf,
regmatch.startpos[0].lnum + lnum, FALSE),
regmatch.startpos[0].lnum + lnum,
regmatch.startpos[0].col + 1,
FALSE,
NULL,
0,
0,
TRUE
) == FAIL)
{
got_int = TRUE;
break;
}
found_match = TRUE;
if (--tomatch == 0)
break;
if ((flags & VGR_GLOBAL) == 0
|| regmatch.endpos[0].lnum > 0)
break;
col = regmatch.endpos[0].col
+ (col == regmatch.endpos[0].col);
if (col > (colnr_T)STRLEN(ml_get_buf(buf, lnum, FALSE)))
break;
}
line_breakcheck();
if (got_int)
break;
}
#ifdef FEAT_AUTOCMD
cur_qf_start = qi->qf_lists[qi->qf_curlist].qf_start;
#endif
if (using_dummy)
{
if (found_match && first_match_buf == NULL)
first_match_buf = buf;
if (duplicate_name)
{
wipe_dummy_buffer(buf, dirname_start);
buf = NULL;
}
else if (!cmdmod.hide
|| buf->b_p_bh[0] == 'u'
|| buf->b_p_bh[0] == 'w'
|| buf->b_p_bh[0] == 'd')
{
if (!found_match)
{
wipe_dummy_buffer(buf, dirname_start);
buf = NULL;
}
else if (buf != first_match_buf || (flags & VGR_NOJUMP))
{
unload_dummy_buffer(buf, dirname_start);
buf->b_flags &= ~BF_DUMMY;
buf = NULL;
}
}
if (buf != NULL)
{
buf->b_flags &= ~BF_DUMMY;
if (buf == first_match_buf
&& target_dir == NULL
&& STRCMP(dirname_start, dirname_now) != 0)
target_dir = vim_strsave(dirname_now);
aucmd_prepbuf(&aco, buf);
#if defined(FEAT_AUTOCMD) && defined(FEAT_SYN_HL)
apply_autocmds(EVENT_FILETYPE, buf->b_p_ft,
buf->b_fname, TRUE, buf);
#endif
do_modelines(OPT_NOWIN);
aucmd_restbuf(&aco);
}
}
}
}
FreeWild(fcount, fnames);
qi->qf_lists[qi->qf_curlist].qf_nonevalid = FALSE;
qi->qf_lists[qi->qf_curlist].qf_ptr = qi->qf_lists[qi->qf_curlist].qf_start;
qi->qf_lists[qi->qf_curlist].qf_index = 1;
qf_update_buffer(qi, NULL);
#ifdef FEAT_AUTOCMD
if (au_name != NULL)
apply_autocmds(EVENT_QUICKFIXCMDPOST, au_name,
curbuf->b_fname, TRUE, curbuf);
#endif
if (qi->qf_lists[qi->qf_curlist].qf_count > 0)
{
if ((flags & VGR_NOJUMP) == 0)
{
buf = curbuf;
qf_jump(qi, 0, 0, eap->forceit);
if (buf != curbuf)
redraw_for_dummy = FALSE;
if (curbuf == first_match_buf && target_dir != NULL)
{
exarg_T ea;
ea.arg = target_dir;
ea.cmdidx = CMD_lcd;
ex_cd(&ea);
}
}
}
else
EMSG2(_(e_nomatch2), s);
if (redraw_for_dummy)
{
#ifdef FEAT_FOLDING
foldUpdateAll(curwin);
#else
redraw_later(NOT_VALID);
#endif
}
theend:
vim_free(title);
vim_free(dirname_now);
vim_free(dirname_start);
vim_free(target_dir);
vim_regfree(regmatch.regprog);
}
static void
restore_start_dir(char_u *dirname_start)
{
char_u *dirname_now = alloc(MAXPATHL);
if (NULL != dirname_now)
{
mch_dirname(dirname_now, MAXPATHL);
if (STRCMP(dirname_start, dirname_now) != 0)
{
exarg_T ea;
ea.arg = dirname_start;
ea.cmdidx = (curwin->w_localdir == NULL) ? CMD_cd : CMD_lcd;
ex_cd(&ea);
}
vim_free(dirname_now);
}
}
static buf_T *
load_dummy_buffer(
char_u *fname,
char_u *dirname_start,
char_u *resulting_dir)
{
buf_T *newbuf;
bufref_T newbufref;
bufref_T newbuf_to_wipe;
int failed = TRUE;
aco_save_T aco;
newbuf = buflist_new(NULL, NULL, (linenr_T)1, BLN_DUMMY);
if (newbuf == NULL)
return NULL;
set_bufref(&newbufref, newbuf);
buf_copy_options(newbuf, BCO_ENTER | BCO_NOHELP);
if (ml_open(newbuf) == OK)
{
aucmd_prepbuf(&aco, newbuf);
(void)setfname(curbuf, fname, NULL, FALSE);
check_need_swap(TRUE);
curbuf->b_flags &= ~BF_DUMMY;
newbuf_to_wipe.br_buf = NULL;
if (readfile(fname, NULL,
(linenr_T)0, (linenr_T)0, (linenr_T)MAXLNUM,
NULL, READ_NEW | READ_DUMMY) == OK
&& !got_int
&& !(curbuf->b_flags & BF_NEW))
{
failed = FALSE;
if (curbuf != newbuf)
{
set_bufref(&newbuf_to_wipe, newbuf);
newbuf = curbuf;
}
}
aucmd_restbuf(&aco);
if (newbuf_to_wipe.br_buf != NULL && bufref_valid(&newbuf_to_wipe))
wipe_buffer(newbuf_to_wipe.br_buf, FALSE);
newbuf->b_flags |= BF_DUMMY;
}
mch_dirname(resulting_dir, MAXPATHL);
restore_start_dir(dirname_start);
if (!bufref_valid(&newbufref))
return NULL;
if (failed)
{
wipe_dummy_buffer(newbuf, dirname_start);
return NULL;
}
return newbuf;
}
static void
wipe_dummy_buffer(buf_T *buf, char_u *dirname_start)
{
if (curbuf != buf)
{
#if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
cleanup_T cs;
enter_cleanup(&cs);
#endif
wipe_buffer(buf, FALSE);
#if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
leave_cleanup(&cs);
#endif
restore_start_dir(dirname_start);
}
}
static void
unload_dummy_buffer(buf_T *buf, char_u *dirname_start)
{
if (curbuf != buf)
{
close_buffer(NULL, buf, DOBUF_UNLOAD, FALSE);
restore_start_dir(dirname_start);
}
}
#if defined(FEAT_EVAL) || defined(PROTO)
int
get_errorlist(qf_info_T *qi_arg, win_T *wp, int qf_idx, list_T *list)
{
qf_info_T *qi = qi_arg;
dict_T *dict;
char_u buf[2];
qfline_T *qfp;
int i;
int bufnum;
if (qi == NULL)
{
qi = &ql_info;
if (wp != NULL)
{
qi = GET_LOC_LIST(wp);
if (qi == NULL)
return FAIL;
}
}
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[qf_idx].qf_start;
for (i = 1; !got_int && i <= qi->qf_lists[qf_idx].qf_count; ++i)
{
bufnum = qfp->qf_fnum;
if (bufnum != 0 && (buflist_findnr(bufnum) == NULL))
bufnum = 0;
if ((dict = dict_alloc()) == NULL)
return FAIL;
if (list_append_dict(list, dict) == FAIL)
return FAIL;
buf[0] = qfp->qf_type;
buf[1] = NUL;
if ( dict_add_nr_str(dict, "bufnr", (long)bufnum, NULL) == FAIL
|| dict_add_nr_str(dict, "lnum", (long)qfp->qf_lnum, NULL) == FAIL
|| dict_add_nr_str(dict, "col", (long)qfp->qf_col, NULL) == FAIL
|| dict_add_nr_str(dict, "vcol", (long)qfp->qf_viscol, NULL) == FAIL
|| dict_add_nr_str(dict, "nr", (long)qfp->qf_nr, NULL) == FAIL
|| dict_add_nr_str(dict, "pattern", 0L,
qfp->qf_pattern == NULL ? (char_u *)"" : qfp->qf_pattern) == FAIL
|| dict_add_nr_str(dict, "text", 0L,
qfp->qf_text == NULL ? (char_u *)"" : qfp->qf_text) == FAIL
|| dict_add_nr_str(dict, "type", 0L, buf) == FAIL
|| dict_add_nr_str(dict, "valid", (long)qfp->qf_valid, NULL) == FAIL)
return FAIL;
qfp = qfp->qf_next;
if (qfp == NULL)
break;
}
return OK;
}
enum {
QF_GETLIST_NONE = 0x0,
QF_GETLIST_TITLE = 0x1,
QF_GETLIST_ITEMS = 0x2,
QF_GETLIST_NR = 0x4,
QF_GETLIST_WINID = 0x8,
QF_GETLIST_CONTEXT = 0x10,
QF_GETLIST_ID = 0x20,
QF_GETLIST_IDX = 0x40,
QF_GETLIST_SIZE = 0x80,
QF_GETLIST_ALL = 0xFF
};
static int
qf_get_list_from_lines(dict_T *what, dictitem_T *di, dict_T *retdict)
{
int status = FAIL;
qf_info_T *qi;
char_u *errorformat = p_efm;
dictitem_T *efm_di;
list_T *l;
if (di->di_tv.v_type == VAR_LIST && di->di_tv.vval.v_list != NULL)
{
if ((efm_di = dict_find(what, (char_u *)"efm", -1)) != NULL)
{
if (efm_di->di_tv.v_type != VAR_STRING ||
efm_di->di_tv.vval.v_string == NULL)
return FAIL;
errorformat = efm_di->di_tv.vval.v_string;
}
l = list_alloc();
if (l == NULL)
return FAIL;
qi = (qf_info_T *)alloc((unsigned)sizeof(qf_info_T));
if (qi != NULL)
{
vim_memset(qi, 0, (size_t)(sizeof(qf_info_T)));
qi->qf_refcount++;
if (qf_init_ext(qi, 0, NULL, NULL, &di->di_tv, errorformat,
TRUE, (linenr_T)0, (linenr_T)0, NULL, NULL) > 0)
{
(void)get_errorlist(qi, NULL, 0, l);
qf_free(qi, 0);
}
free(qi);
}
dict_add_list(retdict, "items", l);
status = OK;
}
return status;
}
static int
qf_id2nr(qf_info_T *qi, int_u qfid)
{
int qf_idx;
for (qf_idx = 0; qf_idx < qi->qf_listcount; qf_idx++)
if (qi->qf_lists[qf_idx].qf_id == qfid)
return qf_idx;
return -1;
}
int
qf_get_properties(win_T *wp, dict_T *what, dict_T *retdict)
{
qf_info_T *qi = &ql_info;
int status = OK;
int qf_idx;
dictitem_T *di;
int flags = QF_GETLIST_NONE;
if ((di = dict_find(what, (char_u *)"lines", -1)) != NULL)
return qf_get_list_from_lines(what, di, retdict);
if (wp != NULL)
qi = GET_LOC_LIST(wp);
if (qi == NULL || qi->qf_listcount == 0)
{
if (((di = dict_find(what, (char_u *)"nr", -1)) != NULL)
&& (di->di_tv.v_type == VAR_STRING)
&& (STRCMP(di->di_tv.vval.v_string, "$") == 0))
return dict_add_nr_str(retdict, "nr", 0, NULL);
return FAIL;
}
qf_idx = qi->qf_curlist;
if ((di = dict_find(what, (char_u *)"nr", -1)) != NULL)
{
if (di->di_tv.v_type == VAR_NUMBER)
{
if (di->di_tv.vval.v_number != 0)
{
qf_idx = di->di_tv.vval.v_number - 1;
if (qf_idx < 0 || qf_idx >= qi->qf_listcount)
return FAIL;
}
}
else if ((di->di_tv.v_type == VAR_STRING)
&& (STRCMP(di->di_tv.vval.v_string, "$") == 0))
qf_idx = qi->qf_listcount - 1;
else
return FAIL;
flags |= QF_GETLIST_NR;
}
if ((di = dict_find(what, (char_u *)"id", -1)) != NULL)
{
if (di->di_tv.v_type == VAR_NUMBER)
{
if (di->di_tv.vval.v_number != 0)
{
qf_idx = qf_id2nr(qi, di->di_tv.vval.v_number);
if (qf_idx == -1)
return FAIL;
}
flags |= QF_GETLIST_ID;
}
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 (dict_find(what, (char_u *)"context", -1) != NULL)
flags |= QF_GETLIST_CONTEXT;
if (dict_find(what, (char_u *)"items", -1) != NULL)
flags |= QF_GETLIST_ITEMS;
if (dict_find(what, (char_u *)"idx", -1) != NULL)
flags |= QF_GETLIST_IDX;
if (dict_find(what, (char_u *)"size", -1) != NULL)
flags |= QF_GETLIST_SIZE;
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 + 1, 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);
}
if ((status == OK) && (flags & QF_GETLIST_ITEMS))
{
list_T *l = list_alloc();
if (l != NULL)
{
(void)get_errorlist(qi, NULL, qf_idx, l);
dict_add_list(retdict, "items", l);
}
else
status = FAIL;
}
if ((status == OK) && (flags & QF_GETLIST_CONTEXT))
{
if (qi->qf_lists[qf_idx].qf_ctx != NULL)
{
di = dictitem_alloc((char_u *)"context");
if (di != NULL)
{
copy_tv(qi->qf_lists[qf_idx].qf_ctx, &di->di_tv);
status = dict_add(retdict, di);
if (status == FAIL)
dictitem_free(di);
}
else
status = FAIL;
}
else
status = dict_add_nr_str(retdict, "context", 0L, (char_u *)"");
}
if ((status == OK) && (flags & QF_GETLIST_ID))
status = dict_add_nr_str(retdict, "id", qi->qf_lists[qf_idx].qf_id,
NULL);
if ((status == OK) && (flags & QF_GETLIST_IDX))
{
int idx = qi->qf_lists[qf_idx].qf_index;
if (qi->qf_lists[qf_idx].qf_count == 0)
idx = 0;
status = dict_add_nr_str(retdict, "idx", idx, NULL);
}
if ((status == OK) && (flags & QF_GETLIST_SIZE))
status = dict_add_nr_str(retdict, "size",
qi->qf_lists[qf_idx].qf_count, NULL);
return status;
}
static int
qf_add_entries(
qf_info_T *qi,
int qf_idx,
list_T *list,
char_u *title,
int action)
{
listitem_T *li;
dict_T *d;
char_u *filename, *pattern, *text, *type;
int bufnum;
long lnum;
int col, nr;
int vcol;
qfline_T *old_last = NULL;
int valid, status;
int retval = OK;
int did_bufnr_emsg = FALSE;
if (action == ' ' || qf_idx == qi->qf_listcount)
{
qf_new_list(qi, title);
qf_idx = qi->qf_curlist;
}
else if (action == 'a' && qi->qf_lists[qf_idx].qf_count > 0)
old_last = qi->qf_lists[qf_idx].qf_last;
else if (action == 'r')
{
qf_free_items(qi, qf_idx);
qf_store_title(qi, qf_idx, title);
}
for (li = list->lv_first; li != NULL; li = li->li_next)
{
if (li->li_tv.v_type != VAR_DICT)
continue;
d = li->li_tv.vval.v_dict;
if (d == NULL)
continue;
filename = get_dict_string(d, (char_u *)"filename", TRUE);
bufnum = (int)get_dict_number(d, (char_u *)"bufnr");
lnum = (int)get_dict_number(d, (char_u *)"lnum");
col = (int)get_dict_number(d, (char_u *)"col");
vcol = (int)get_dict_number(d, (char_u *)"vcol");
nr = (int)get_dict_number(d, (char_u *)"nr");
type = get_dict_string(d, (char_u *)"type", TRUE);
pattern = get_dict_string(d, (char_u *)"pattern", TRUE);
text = get_dict_string(d, (char_u *)"text", TRUE);
if (text == NULL)
text = vim_strsave((char_u *)"");
valid = TRUE;
if ((filename == NULL && bufnum == 0) || (lnum == 0 && pattern == NULL))
valid = FALSE;
if (bufnum != 0 && (buflist_findnr(bufnum) == NULL))
{
if (!did_bufnr_emsg)
{
did_bufnr_emsg = TRUE;
EMSGN(_("E92: Buffer %ld not found"), bufnum);
}
valid = FALSE;
bufnum = 0;
}
if ((dict_find(d, (char_u *)"valid", -1)) != NULL)
valid = (int)get_dict_number(d, (char_u *)"valid");
status = qf_add_entry(qi,
qf_idx,
NULL,
filename,
bufnum,
text,
lnum,
col,
vcol,
pattern,
nr,
type == NULL ? NUL : *type,
valid);
vim_free(filename);
vim_free(pattern);
vim_free(text);
vim_free(type);
if (status == FAIL)
{
retval = FAIL;
break;
}
}
if (qi->qf_lists[qf_idx].qf_index == 0)
qi->qf_lists[qf_idx].qf_nonevalid = TRUE;
else
qi->qf_lists[qf_idx].qf_nonevalid = FALSE;
if (action != 'a')
{
qi->qf_lists[qf_idx].qf_ptr =
qi->qf_lists[qf_idx].qf_start;
if (qi->qf_lists[qf_idx].qf_count > 0)
qi->qf_lists[qf_idx].qf_index = 1;
}
qf_update_buffer(qi, old_last);
return retval;
}
static int
qf_set_properties(qf_info_T *qi, dict_T *what, int action, char_u *title)
{
dictitem_T *di;
int retval = FAIL;
int qf_idx;
int newlist = FALSE;
char_u *errorformat = p_efm;
if (action == ' ' || qi->qf_curlist == qi->qf_listcount)
newlist = TRUE;
qf_idx = qi->qf_curlist;
if ((di = dict_find(what, (char_u *)"nr", -1)) != NULL)
{
if (di->di_tv.v_type == VAR_NUMBER)
{
if (di->di_tv.vval.v_number != 0)
qf_idx = di->di_tv.vval.v_number - 1;
if ((action == ' ' || action == 'a') && qf_idx == qi->qf_listcount)
{
newlist = TRUE;
qf_idx = qi->qf_listcount - 1;
}
else if (qf_idx < 0 || qf_idx >= qi->qf_listcount)
return FAIL;
else if (action != ' ')
newlist = FALSE;
}
else if (di->di_tv.v_type == VAR_STRING
&& STRCMP(di->di_tv.vval.v_string, "$") == 0)
{
if (qi->qf_listcount > 0)
qf_idx = qi->qf_listcount - 1;
else if (newlist)
qf_idx = 0;
else
return FAIL;
}
else
return FAIL;
}
if (!newlist && (di = dict_find(what, (char_u *)"id", -1)) != NULL)
{
if (di->di_tv.v_type == VAR_NUMBER)
{
qf_idx = qf_id2nr(qi, di->di_tv.vval.v_number);
if (qf_idx == -1)
return FAIL;
}
else
return FAIL;
}
if (newlist)
{
qi->qf_curlist = qf_idx;
qf_new_list(qi, title);
qf_idx = qi->qf_curlist;
}
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;
}
}
if ((di = dict_find(what, (char_u *)"items", -1)) != NULL)
{
if (di->di_tv.v_type == VAR_LIST)
{
char_u *title_save = vim_strsave(qi->qf_lists[qf_idx].qf_title);
retval = qf_add_entries(qi, qf_idx, di->di_tv.vval.v_list,
title_save, action == ' ' ? 'a' : action);
if (action == 'r')
{
vim_free(qi->qf_lists[qf_idx].qf_title);
qi->qf_lists[qf_idx].qf_title = vim_strsave(title_save);
}
vim_free(title_save);
}
}
if ((di = dict_find(what, (char_u *)"efm", -1)) != NULL)
{
if (di->di_tv.v_type != VAR_STRING || di->di_tv.vval.v_string == NULL)
return FAIL;
errorformat = di->di_tv.vval.v_string;
}
if ((di = dict_find(what, (char_u *)"lines", -1)) != NULL)
{
if (di->di_tv.v_type == VAR_LIST && di->di_tv.vval.v_list != NULL)
{
if (action == 'r')
qf_free_items(qi, qf_idx);
if (qf_init_ext(qi, qf_idx, NULL, NULL, &di->di_tv, errorformat,
FALSE, (linenr_T)0, (linenr_T)0, NULL, NULL) > 0)
retval = OK;
}
else
return FAIL;
}
if ((di = dict_find(what, (char_u *)"context", -1)) != NULL)
{
typval_T *ctx;
free_tv(qi->qf_lists[qf_idx].qf_ctx);
ctx = alloc_tv();
if (ctx != NULL)
copy_tv(&di->di_tv, ctx);
qi->qf_lists[qf_idx].qf_ctx = ctx;
retval = OK;
}
return retval;
}
static win_T *
find_win_with_ll(qf_info_T *qi)
{
win_T *wp = NULL;
FOR_ALL_WINDOWS(wp)
if ((wp->w_llist == qi) && !bt_quickfix(wp->w_buffer))
return wp;
return NULL;
}
static void
qf_free_stack(win_T *wp, qf_info_T *qi)
{
win_T *qfwin = qf_find_win(qi);
win_T *llwin = NULL;
win_T *orig_wp = wp;
if (qfwin != NULL)
{
if (qi->qf_curlist < qi->qf_listcount)
qf_free(qi, qi->qf_curlist);
qf_update_buffer(qi, NULL);
}
if (wp != NULL && IS_LL_WINDOW(wp))
{
llwin = find_win_with_ll(qi);
if (llwin != NULL)
wp = llwin;
}
qf_free_all(wp);
if (wp == NULL)
{
qi->qf_curlist = 0;
qi->qf_listcount = 0;
}
else if (IS_LL_WINDOW(orig_wp))
{
qf_info_T *new_ll = ll_new_list();
ll_free_all(&orig_wp->w_llist_ref);
orig_wp->w_llist_ref = new_ll;
if (llwin != NULL)
{
llwin->w_llist = new_ll;
new_ll->qf_refcount++;
}
}
}
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 (action == 'f')
{
qf_free_stack(wp, qi);
}
else if (what != NULL)
retval = qf_set_properties(qi, what, action, title);
else
retval = qf_add_entries(qi, qi->qf_curlist, list, title, action);
return retval;
}
static int
mark_quickfix_ctx(qf_info_T *qi, int copyID)
{
int i;
int abort = FALSE;
typval_T *ctx;
for (i = 0; i < LISTCOUNT && !abort; ++i)
{
ctx = qi->qf_lists[i].qf_ctx;
if (ctx != NULL && ctx->v_type != VAR_NUMBER
&& ctx->v_type != VAR_STRING && ctx->v_type != VAR_FLOAT)
abort = set_ref_in_item(ctx, copyID, NULL, NULL);
}
return abort;
}
int
set_ref_in_quickfix(int copyID)
{
int abort = FALSE;
tabpage_T *tp;
win_T *win;
abort = mark_quickfix_ctx(&ql_info, copyID);
if (abort)
return abort;
FOR_ALL_TAB_WINDOWS(tp, win)
{
if (win->w_llist != NULL)
{
abort = mark_quickfix_ctx(win->w_llist, copyID);
if (abort)
return abort;
}
}
return abort;
}
#endif
void
ex_cbuffer(exarg_T *eap)
{
buf_T *buf = NULL;
qf_info_T *qi = &ql_info;
#ifdef FEAT_AUTOCMD
char_u *au_name = NULL;
#endif
if (eap->cmdidx == CMD_lbuffer || eap->cmdidx == CMD_lgetbuffer
|| eap->cmdidx == CMD_laddbuffer)
{
qi = ll_get_or_alloc_list(curwin);
if (qi == NULL)
return;
}
#ifdef FEAT_AUTOCMD
switch (eap->cmdidx)
{
case CMD_cbuffer: au_name = (char_u *)"cbuffer"; break;
case CMD_cgetbuffer: au_name = (char_u *)"cgetbuffer"; break;
case CMD_caddbuffer: au_name = (char_u *)"caddbuffer"; break;
case CMD_lbuffer: au_name = (char_u *)"lbuffer"; break;
case CMD_lgetbuffer: au_name = (char_u *)"lgetbuffer"; break;
case CMD_laddbuffer: au_name = (char_u *)"laddbuffer"; break;
default: break;
}
if (au_name != NULL && apply_autocmds(EVENT_QUICKFIXCMDPRE, au_name,
curbuf->b_fname, TRUE, curbuf))
{
# ifdef FEAT_EVAL
if (aborting())
return;
# endif
}
#endif
if (*eap->arg == NUL)
buf = curbuf;
else if (*skipwhite(skipdigits(eap->arg)) == NUL)
buf = buflist_findnr(atoi((char *)eap->arg));
if (buf == NULL)
EMSG(_(e_invarg));
else if (buf->b_ml.ml_mfp == NULL)
EMSG(_("E681: Buffer is not loaded"));
else
{
if (eap->addr_count == 0)
{
eap->line1 = 1;
eap->line2 = buf->b_ml.ml_line_count;
}
if (eap->line1 < 1 || eap->line1 > buf->b_ml.ml_line_count
|| eap->line2 < 1 || eap->line2 > buf->b_ml.ml_line_count)
EMSG(_(e_invrange));
else
{
char_u *qf_title = *eap->cmdlinep;
if (buf->b_sfname)
{
vim_snprintf((char *)IObuff, IOSIZE, "%s (%s)",
(char *)qf_title, (char *)buf->b_sfname);
qf_title = IObuff;
}
if (qf_init_ext(qi, qi->qf_curlist, NULL, buf, NULL, p_efm,
(eap->cmdidx != CMD_caddbuffer
&& eap->cmdidx != CMD_laddbuffer),
eap->line1, eap->line2,
qf_title, NULL) > 0)
{
#ifdef FEAT_AUTOCMD
if (au_name != NULL)
apply_autocmds(EVENT_QUICKFIXCMDPOST, au_name,
curbuf->b_fname, TRUE, curbuf);
#endif
if (eap->cmdidx == CMD_cbuffer || eap->cmdidx == CMD_lbuffer)
qf_jump(qi, 0, 0, eap->forceit);
}
}
}
}
#if defined(FEAT_EVAL) || defined(PROTO)
void
ex_cexpr(exarg_T *eap)
{
typval_T *tv;
qf_info_T *qi = &ql_info;
#ifdef FEAT_AUTOCMD
char_u *au_name = NULL;
#endif
if (eap->cmdidx == CMD_lexpr || eap->cmdidx == CMD_lgetexpr
|| eap->cmdidx == CMD_laddexpr)
{
qi = ll_get_or_alloc_list(curwin);
if (qi == NULL)
return;
}
#ifdef FEAT_AUTOCMD
switch (eap->cmdidx)
{
case CMD_cexpr: au_name = (char_u *)"cexpr"; break;
case CMD_cgetexpr: au_name = (char_u *)"cgetexpr"; break;
case CMD_caddexpr: au_name = (char_u *)"caddexpr"; break;
case CMD_lexpr: au_name = (char_u *)"lexpr"; break;
case CMD_lgetexpr: au_name = (char_u *)"lgetexpr"; break;
case CMD_laddexpr: au_name = (char_u *)"laddexpr"; break;
default: break;
}
if (au_name != NULL && apply_autocmds(EVENT_QUICKFIXCMDPRE, au_name,
curbuf->b_fname, TRUE, curbuf))
{
# ifdef FEAT_EVAL
if (aborting())
return;
# endif
}
#endif
tv = eval_expr(eap->arg, NULL);
if (tv != NULL)
{
if ((tv->v_type == VAR_STRING && tv->vval.v_string != NULL)
|| (tv->v_type == VAR_LIST && tv->vval.v_list != NULL))
{
if (qf_init_ext(qi, qi->qf_curlist, NULL, NULL, tv, p_efm,
(eap->cmdidx != CMD_caddexpr
&& eap->cmdidx != CMD_laddexpr),
(linenr_T)0, (linenr_T)0, *eap->cmdlinep,
NULL) > 0)
{
#ifdef FEAT_AUTOCMD
if (au_name != NULL)
apply_autocmds(EVENT_QUICKFIXCMDPOST, au_name,
curbuf->b_fname, TRUE, curbuf);
#endif
if (eap->cmdidx == CMD_cexpr || eap->cmdidx == CMD_lexpr)
qf_jump(qi, 0, 0, eap->forceit);
}
}
else
EMSG(_("E777: String or List expected"));
free_tv(tv);
}
}
#endif
void
ex_helpgrep(exarg_T *eap)
{
regmatch_T regmatch;
char_u *save_cpo;
char_u *p;
int fcount;
char_u **fnames;
FILE *fd;
int fi;
long lnum;
#ifdef FEAT_MULTI_LANG
char_u *lang;
#endif
qf_info_T *qi = &ql_info;
qf_info_T *save_qi;
int new_qi = FALSE;
win_T *wp;
#ifdef FEAT_AUTOCMD
char_u *au_name = NULL;
#endif
#ifdef FEAT_MULTI_LANG
lang = check_help_lang(eap->arg);
#endif
#ifdef FEAT_AUTOCMD
switch (eap->cmdidx)
{
case CMD_helpgrep: au_name = (char_u *)"helpgrep"; break;
case CMD_lhelpgrep: au_name = (char_u *)"lhelpgrep"; break;
default: break;
}
if (au_name != NULL && apply_autocmds(EVENT_QUICKFIXCMDPRE, au_name,
curbuf->b_fname, TRUE, curbuf))
{
# ifdef FEAT_EVAL
if (aborting())
return;
# endif
}
#endif
save_cpo = p_cpo;
p_cpo = empty_option;
if (eap->cmdidx == CMD_lhelpgrep)
{
if (bt_help(curwin->w_buffer))
wp = curwin;
else
FOR_ALL_WINDOWS(wp)
if (bt_help(wp->w_buffer))
break;
if (wp == NULL)
qi = NULL;
else
qi = wp->w_llist;
if (qi == NULL)
{
if ((qi = ll_new_list()) == NULL)
return;
new_qi = TRUE;
}
}
save_qi = qi;
regmatch.regprog = vim_regcomp(eap->arg, RE_MAGIC + RE_STRING);
regmatch.rm_ic = FALSE;
if (regmatch.regprog != NULL)
{
#ifdef FEAT_MBYTE
vimconv_T vc;
vc.vc_type = CONV_NONE;
if (!enc_utf8)
convert_setup(&vc, (char_u *)"utf-8", p_enc);
#endif
qf_new_list(qi, *eap->cmdlinep);
p = p_rtp;
while (*p != NUL && !got_int)
{
copy_option_part(&p, NameBuff, MAXPATHL, ",");
add_pathsep(NameBuff);
STRCAT(NameBuff, "doc/*.\\(txt\\|??x\\)");
if (gen_expand_wildcards(1, &NameBuff, &fcount,
&fnames, EW_FILE|EW_SILENT) == OK
&& fcount > 0)
{
for (fi = 0; fi < fcount && !got_int; ++fi)
{
#ifdef FEAT_MULTI_LANG
if (lang != NULL
&& STRNICMP(lang, fnames[fi]
+ STRLEN(fnames[fi]) - 3, 2) != 0
&& !(STRNICMP(lang, "en", 2) == 0
&& STRNICMP("txt", fnames[fi]
+ STRLEN(fnames[fi]) - 3, 3) == 0))
continue;
#endif
fd = mch_fopen((char *)fnames[fi], "r");
if (fd != NULL)
{
lnum = 1;
while (!vim_fgets(IObuff, IOSIZE, fd) && !got_int)
{
char_u *line = IObuff;
#ifdef FEAT_MBYTE
if (vc.vc_type != CONV_NONE
&& has_non_ascii(IObuff))
{
line = string_convert(&vc, IObuff, NULL);
if (line == NULL)
line = IObuff;
}
#endif
if (vim_regexec(®match, line, (colnr_T)0))
{
int l = (int)STRLEN(line);
while (l > 0 && line[l - 1] <= ' ')
line[--l] = NUL;
if (qf_add_entry(qi,
qi->qf_curlist,
NULL,
fnames[fi],
0,
line,
lnum,
(int)(regmatch.startp[0] - line)
+ 1,
FALSE,
NULL,
0,
1,
TRUE
) == FAIL)
{
got_int = TRUE;
#ifdef FEAT_MBYTE
if (line != IObuff)
vim_free(line);
#endif
break;
}
}
#ifdef FEAT_MBYTE
if (line != IObuff)
vim_free(line);
#endif
++lnum;
line_breakcheck();
}
fclose(fd);
}
}
FreeWild(fcount, fnames);
}
}
vim_regfree(regmatch.regprog);
#ifdef FEAT_MBYTE
if (vc.vc_type != CONV_NONE)
convert_setup(&vc, NULL, NULL);
#endif
qi->qf_lists[qi->qf_curlist].qf_nonevalid = FALSE;
qi->qf_lists[qi->qf_curlist].qf_ptr =
qi->qf_lists[qi->qf_curlist].qf_start;
qi->qf_lists[qi->qf_curlist].qf_index = 1;
}
if (p_cpo == empty_option)
p_cpo = save_cpo;
else
free_string_option(save_cpo);
qf_update_buffer(qi, NULL);
#ifdef FEAT_AUTOCMD
if (au_name != NULL)
{
apply_autocmds(EVENT_QUICKFIXCMDPOST, au_name,
curbuf->b_fname, TRUE, curbuf);
if (!new_qi && qi != save_qi && qf_find_buf(qi) == NULL)
return;
}
#endif
if (qi->qf_lists[qi->qf_curlist].qf_count > 0)
qf_jump(qi, 0, 0, FALSE);
else
EMSG2(_(e_nomatch2), eap->arg);
if (eap->cmdidx == CMD_lhelpgrep)
{
if (!bt_help(curwin->w_buffer) || curwin->w_llist == qi)
{
if (new_qi)
ll_free_all(&qi);
}
else if (curwin->w_llist == NULL)
curwin->w_llist = qi;
}
}
#endif