1 /* vi:set ts=8 sts=4 sw=4 noet: 2 * 3 * VIM - Vi IMproved by Bram Moolenaar 4 * 5 * Do ":help uganda" in Vim to read copying and usage conditions. 6 * Do ":help credits" in Vim to see a list of people who contributed. 7 * See README.txt for an overview of the Vim source code. 8 */ 9 10 /* 11 * quickfix.c: functions for quickfix mode, using a file with error messages 12 */ 13 14 #include "vim.h" 15 16 #if defined(FEAT_QUICKFIX) || defined(PROTO) 17 18 struct dir_stack_T 19 { 20 struct dir_stack_T *next; 21 char_u *dirname; 22 }; 23 24 /* 25 * For each error the next struct is allocated and linked in a list. 26 */ 27 typedef struct qfline_S qfline_T; 28 struct qfline_S 29 { 30 qfline_T *qf_next; // pointer to next error in the list 31 qfline_T *qf_prev; // pointer to previous error in the list 32 linenr_T qf_lnum; // line number where the error occurred 33 int qf_fnum; // file number for the line 34 int qf_col; // column where the error occurred 35 int qf_nr; // error number 36 char_u *qf_module; // module name for this error 37 char_u *qf_pattern; // search pattern for the error 38 char_u *qf_text; // description of the error 39 char_u qf_viscol; // set to TRUE if qf_col is screen column 40 char_u qf_cleared; // set to TRUE if line has been deleted 41 char_u qf_type; // type of the error (mostly 'E'); 1 for 42 // :helpgrep 43 char_u qf_valid; // valid error message detected 44 }; 45 46 /* 47 * There is a stack of error lists. 48 */ 49 #define LISTCOUNT 10 50 #define INVALID_QFIDX (-1) 51 #define INVALID_QFBUFNR (0) 52 53 /* 54 * Quickfix list type. 55 */ 56 typedef enum 57 { 58 QFLT_QUICKFIX, // Quickfix list - global list 59 QFLT_LOCATION, // Location list - per window list 60 QFLT_INTERNAL // Internal - Temporary list used by getqflist()/getloclist() 61 } qfltype_T; 62 63 /* 64 * Quickfix/Location list definition 65 * Contains a list of entries (qfline_T). qf_start points to the first entry 66 * and qf_last points to the last entry. qf_count contains the list size. 67 * 68 * Usually the list contains one or more entries. But an empty list can be 69 * created using setqflist()/setloclist() with a title and/or user context 70 * information and entries can be added later using setqflist()/setloclist(). 71 */ 72 typedef struct qf_list_S 73 { 74 int_u qf_id; // Unique identifier for this list 75 qfltype_T qfl_type; 76 qfline_T *qf_start; // pointer to the first error 77 qfline_T *qf_last; // pointer to the last error 78 qfline_T *qf_ptr; // pointer to the current error 79 int qf_count; // number of errors (0 means empty list) 80 int qf_index; // current index in the error list 81 int qf_nonevalid; // TRUE if not a single valid entry found 82 char_u *qf_title; // title derived from the command that created 83 // the error list or set by setqflist 84 typval_T *qf_ctx; // context set by setqflist/setloclist 85 86 struct dir_stack_T *qf_dir_stack; 87 char_u *qf_directory; 88 struct dir_stack_T *qf_file_stack; 89 char_u *qf_currfile; 90 int qf_multiline; 91 int qf_multiignore; 92 int qf_multiscan; 93 long qf_changedtick; 94 } qf_list_T; 95 96 /* 97 * Quickfix/Location list stack definition 98 * Contains a list of quickfix/location lists (qf_list_T) 99 */ 100 struct qf_info_S 101 { 102 // Count of references to this list. Used only for location lists. 103 // When a location list window reference this list, qf_refcount 104 // will be 2. Otherwise, qf_refcount will be 1. When qf_refcount 105 // reaches 0, the list is freed. 106 int qf_refcount; 107 int qf_listcount; // current number of lists 108 int qf_curlist; // current error list 109 qf_list_T qf_lists[LISTCOUNT]; 110 qfltype_T qfl_type; // type of list 111 int qf_bufnr; // quickfix window buffer number 112 }; 113 114 static qf_info_T ql_info; // global quickfix list 115 static int_u last_qf_id = 0; // Last used quickfix list id 116 117 #define FMT_PATTERNS 11 // maximum number of % recognized 118 119 /* 120 * Structure used to hold the info of one part of 'errorformat' 121 */ 122 typedef struct efm_S efm_T; 123 struct efm_S 124 { 125 regprog_T *prog; // pre-formatted part of 'errorformat' 126 efm_T *next; // pointer to next (NULL if last) 127 char_u addr[FMT_PATTERNS]; // indices of used % patterns 128 char_u prefix; // prefix of this format line: 129 // 'D' enter directory 130 // 'X' leave directory 131 // 'A' start of multi-line message 132 // 'E' error message 133 // 'W' warning message 134 // 'I' informational message 135 // 'C' continuation line 136 // 'Z' end of multi-line message 137 // 'G' general, unspecific message 138 // 'P' push file (partial) message 139 // 'Q' pop/quit file (partial) message 140 // 'O' overread (partial) message 141 char_u flags; // additional flags given in prefix 142 // '-' do not include this line 143 // '+' include whole line in message 144 int conthere; // %> used 145 }; 146 147 // List of location lists to be deleted. 148 // Used to delay the deletion of locations lists by autocmds. 149 typedef struct qf_delq_S 150 { 151 struct qf_delq_S *next; 152 qf_info_T *qi; 153 } qf_delq_T; 154 static qf_delq_T *qf_delq_head = NULL; 155 156 // Counter to prevent autocmds from freeing up location lists when they are 157 // still being used. 158 static int quickfix_busy = 0; 159 160 static efm_T *fmt_start = NULL; // cached across qf_parse_line() calls 161 162 static void qf_new_list(qf_info_T *qi, char_u *qf_title); 163 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); 164 static void qf_free(qf_list_T *qfl); 165 static char_u *qf_types(int, int); 166 static int qf_get_fnum(qf_list_T *qfl, char_u *, char_u *); 167 static char_u *qf_push_dir(char_u *, struct dir_stack_T **, int is_file_stack); 168 static char_u *qf_pop_dir(struct dir_stack_T **); 169 static char_u *qf_guess_filepath(qf_list_T *qfl, char_u *); 170 static void qf_fmt_text(char_u *text, char_u *buf, int bufsize); 171 static int qf_win_pos_update(qf_info_T *qi, int old_qf_index); 172 static win_T *qf_find_win(qf_info_T *qi); 173 static buf_T *qf_find_buf(qf_info_T *qi); 174 static void qf_update_buffer(qf_info_T *qi, qfline_T *old_last); 175 static void qf_fill_buffer(qf_list_T *qfl, buf_T *buf, qfline_T *old_last); 176 static buf_T *load_dummy_buffer(char_u *fname, char_u *dirname_start, char_u *resulting_dir); 177 static void wipe_dummy_buffer(buf_T *buf, char_u *dirname_start); 178 static void unload_dummy_buffer(buf_T *buf, char_u *dirname_start); 179 static qf_info_T *ll_get_or_alloc_list(win_T *); 180 181 // Quickfix window check helper macro 182 #define IS_QF_WINDOW(wp) (bt_quickfix(wp->w_buffer) && wp->w_llist_ref == NULL) 183 // Location list window check helper macro 184 #define IS_LL_WINDOW(wp) (bt_quickfix(wp->w_buffer) && wp->w_llist_ref != NULL) 185 186 // Quickfix and location list stack check helper macros 187 #define IS_QF_STACK(qi) (qi->qfl_type == QFLT_QUICKFIX) 188 #define IS_LL_STACK(qi) (qi->qfl_type == QFLT_LOCATION) 189 #define IS_QF_LIST(qfl) (qfl->qfl_type == QFLT_QUICKFIX) 190 #define IS_LL_LIST(qfl) (qfl->qfl_type == QFLT_LOCATION) 191 192 /* 193 * Return location list for window 'wp' 194 * For location list window, return the referenced location list 195 */ 196 #define GET_LOC_LIST(wp) (IS_LL_WINDOW(wp) ? wp->w_llist_ref : wp->w_llist) 197 198 /* 199 * Looking up a buffer can be slow if there are many. Remember the last one 200 * to make this a lot faster if there are multiple matches in the same file. 201 */ 202 static char_u *qf_last_bufname = NULL; 203 static bufref_T qf_last_bufref = {NULL, 0, 0}; 204 205 static char *e_loc_list_changed = 206 N_("E926: Current location list was changed"); 207 208 /* 209 * Maximum number of bytes allowed per line while reading a errorfile. 210 */ 211 #define LINE_MAXLEN 4096 212 213 static struct fmtpattern 214 { 215 char_u convchar; 216 char *pattern; 217 } fmt_pat[FMT_PATTERNS] = 218 { 219 {'f', ".\\+"}, // only used when at end 220 {'n', "\\d\\+"}, 221 {'l', "\\d\\+"}, 222 {'c', "\\d\\+"}, 223 {'t', "."}, 224 {'m', ".\\+"}, 225 {'r', ".*"}, 226 {'p', "[- .]*"}, 227 {'v', "\\d\\+"}, 228 {'s', ".\\+"}, 229 {'o', ".\\+"} 230 }; 231 232 /* 233 * Convert an errorformat pattern to a regular expression pattern. 234 * See fmt_pat definition above for the list of supported patterns. The 235 * pattern specifier is supplied in "efmpat". The converted pattern is stored 236 * in "regpat". Returns a pointer to the location after the pattern. 237 */ 238 static char_u * 239 efmpat_to_regpat( 240 char_u *efmpat, 241 char_u *regpat, 242 efm_T *efminfo, 243 int idx, 244 int round) 245 { 246 char_u *srcptr; 247 248 if (efminfo->addr[idx]) 249 { 250 // Each errorformat pattern can occur only once 251 semsg(_("E372: Too many %%%c in format string"), *efmpat); 252 return NULL; 253 } 254 if ((idx && idx < 6 255 && vim_strchr((char_u *)"DXOPQ", efminfo->prefix) != NULL) 256 || (idx == 6 257 && vim_strchr((char_u *)"OPQ", efminfo->prefix) == NULL)) 258 { 259 semsg(_("E373: Unexpected %%%c in format string"), *efmpat); 260 return NULL; 261 } 262 efminfo->addr[idx] = (char_u)++round; 263 *regpat++ = '\\'; 264 *regpat++ = '('; 265 #ifdef BACKSLASH_IN_FILENAME 266 if (*efmpat == 'f') 267 { 268 // Also match "c:" in the file name, even when 269 // checking for a colon next: "%f:". 270 // "\%(\a:\)\=" 271 STRCPY(regpat, "\\%(\\a:\\)\\="); 272 regpat += 10; 273 } 274 #endif 275 if (*efmpat == 'f' && efmpat[1] != NUL) 276 { 277 if (efmpat[1] != '\\' && efmpat[1] != '%') 278 { 279 // A file name may contain spaces, but this isn't 280 // in "\f". For "%f:%l:%m" there may be a ":" in 281 // the file name. Use ".\{-1,}x" instead (x is 282 // the next character), the requirement that :999: 283 // follows should work. 284 STRCPY(regpat, ".\\{-1,}"); 285 regpat += 7; 286 } 287 else 288 { 289 // File name followed by '\\' or '%': include as 290 // many file name chars as possible. 291 STRCPY(regpat, "\\f\\+"); 292 regpat += 4; 293 } 294 } 295 else 296 { 297 srcptr = (char_u *)fmt_pat[idx].pattern; 298 while ((*regpat = *srcptr++) != NUL) 299 ++regpat; 300 } 301 *regpat++ = '\\'; 302 *regpat++ = ')'; 303 304 return regpat; 305 } 306 307 /* 308 * Convert a scanf like format in 'errorformat' to a regular expression. 309 * Returns a pointer to the location after the pattern. 310 */ 311 static char_u * 312 scanf_fmt_to_regpat( 313 char_u **pefmp, 314 char_u *efm, 315 int len, 316 char_u *regpat) 317 { 318 char_u *efmp = *pefmp; 319 320 if (*efmp == '[' || *efmp == '\\') 321 { 322 if ((*regpat++ = *efmp) == '[') // %*[^a-z0-9] etc. 323 { 324 if (efmp[1] == '^') 325 *regpat++ = *++efmp; 326 if (efmp < efm + len) 327 { 328 *regpat++ = *++efmp; // could be ']' 329 while (efmp < efm + len 330 && (*regpat++ = *++efmp) != ']') 331 // skip ; 332 if (efmp == efm + len) 333 { 334 emsg(_("E374: Missing ] in format string")); 335 return NULL; 336 } 337 } 338 } 339 else if (efmp < efm + len) // %*\D, %*\s etc. 340 *regpat++ = *++efmp; 341 *regpat++ = '\\'; 342 *regpat++ = '+'; 343 } 344 else 345 { 346 // TODO: scanf()-like: %*ud, %*3c, %*f, ... ? 347 semsg(_("E375: Unsupported %%%c in format string"), *efmp); 348 return NULL; 349 } 350 351 *pefmp = efmp; 352 353 return regpat; 354 } 355 356 /* 357 * Analyze/parse an errorformat prefix. 358 */ 359 static char_u * 360 efm_analyze_prefix(char_u *efmp, efm_T *efminfo) 361 { 362 if (vim_strchr((char_u *)"+-", *efmp) != NULL) 363 efminfo->flags = *efmp++; 364 if (vim_strchr((char_u *)"DXAEWICZGOPQ", *efmp) != NULL) 365 efminfo->prefix = *efmp; 366 else 367 { 368 semsg(_("E376: Invalid %%%c in format string prefix"), *efmp); 369 return NULL; 370 } 371 372 return efmp; 373 } 374 375 /* 376 * Converts a 'errorformat' string part in 'efm' to a regular expression 377 * pattern. The resulting regex pattern is returned in "regpat". Additional 378 * information about the 'erroformat' pattern is returned in "fmt_ptr". 379 * Returns OK or FAIL. 380 */ 381 static int 382 efm_to_regpat( 383 char_u *efm, 384 int len, 385 efm_T *fmt_ptr, 386 char_u *regpat) 387 { 388 char_u *ptr; 389 char_u *efmp; 390 int round; 391 int idx = 0; 392 393 // Build a regexp pattern for a 'errorformat' option part 394 ptr = regpat; 395 *ptr++ = '^'; 396 round = 0; 397 for (efmp = efm; efmp < efm + len; ++efmp) 398 { 399 if (*efmp == '%') 400 { 401 ++efmp; 402 for (idx = 0; idx < FMT_PATTERNS; ++idx) 403 if (fmt_pat[idx].convchar == *efmp) 404 break; 405 if (idx < FMT_PATTERNS) 406 { 407 ptr = efmpat_to_regpat(efmp, ptr, fmt_ptr, idx, round); 408 if (ptr == NULL) 409 return FAIL; 410 round++; 411 } 412 else if (*efmp == '*') 413 { 414 ++efmp; 415 ptr = scanf_fmt_to_regpat(&efmp, efm, len, ptr); 416 if (ptr == NULL) 417 return FAIL; 418 } 419 else if (vim_strchr((char_u *)"%\\.^$~[", *efmp) != NULL) 420 *ptr++ = *efmp; // regexp magic characters 421 else if (*efmp == '#') 422 *ptr++ = '*'; 423 else if (*efmp == '>') 424 fmt_ptr->conthere = TRUE; 425 else if (efmp == efm + 1) // analyse prefix 426 { 427 // prefix is allowed only at the beginning of the errorformat 428 // option part 429 efmp = efm_analyze_prefix(efmp, fmt_ptr); 430 if (efmp == NULL) 431 return FAIL; 432 } 433 else 434 { 435 semsg(_("E377: Invalid %%%c in format string"), *efmp); 436 return FAIL; 437 } 438 } 439 else // copy normal character 440 { 441 if (*efmp == '\\' && efmp + 1 < efm + len) 442 ++efmp; 443 else if (vim_strchr((char_u *)".*^$~[", *efmp) != NULL) 444 *ptr++ = '\\'; // escape regexp atoms 445 if (*efmp) 446 *ptr++ = *efmp; 447 } 448 } 449 *ptr++ = '$'; 450 *ptr = NUL; 451 452 return OK; 453 } 454 455 /* 456 * Free the 'errorformat' information list 457 */ 458 static void 459 free_efm_list(efm_T **efm_first) 460 { 461 efm_T *efm_ptr; 462 463 for (efm_ptr = *efm_first; efm_ptr != NULL; efm_ptr = *efm_first) 464 { 465 *efm_first = efm_ptr->next; 466 vim_regfree(efm_ptr->prog); 467 vim_free(efm_ptr); 468 } 469 fmt_start = NULL; 470 } 471 472 /* 473 * Compute the size of the buffer used to convert a 'errorformat' pattern into 474 * a regular expression pattern. 475 */ 476 static int 477 efm_regpat_bufsz(char_u *efm) 478 { 479 int sz; 480 int i; 481 482 sz = (FMT_PATTERNS * 3) + ((int)STRLEN(efm) << 2); 483 for (i = FMT_PATTERNS; i > 0; ) 484 sz += (int)STRLEN(fmt_pat[--i].pattern); 485 #ifdef BACKSLASH_IN_FILENAME 486 sz += 12; // "%f" can become twelve chars longer (see efm_to_regpat) 487 #else 488 sz += 2; // "%f" can become two chars longer 489 #endif 490 491 return sz; 492 } 493 494 /* 495 * Return the length of a 'errorformat' option part (separated by ","). 496 */ 497 static int 498 efm_option_part_len(char_u *efm) 499 { 500 int len; 501 502 for (len = 0; efm[len] != NUL && efm[len] != ','; ++len) 503 if (efm[len] == '\\' && efm[len + 1] != NUL) 504 ++len; 505 506 return len; 507 } 508 509 /* 510 * Parse the 'errorformat' option. Multiple parts in the 'errorformat' option 511 * are parsed and converted to regular expressions. Returns information about 512 * the parsed 'errorformat' option. 513 */ 514 static efm_T * 515 parse_efm_option(char_u *efm) 516 { 517 efm_T *fmt_ptr = NULL; 518 efm_T *fmt_first = NULL; 519 efm_T *fmt_last = NULL; 520 char_u *fmtstr = NULL; 521 int len; 522 int sz; 523 524 // Each part of the format string is copied and modified from errorformat 525 // to regex prog. Only a few % characters are allowed. 526 527 // Get some space to modify the format string into. 528 sz = efm_regpat_bufsz(efm); 529 if ((fmtstr = alloc(sz)) == NULL) 530 goto parse_efm_error; 531 532 while (efm[0] != NUL) 533 { 534 // Allocate a new eformat structure and put it at the end of the list 535 fmt_ptr = (efm_T *)alloc_clear((unsigned)sizeof(efm_T)); 536 if (fmt_ptr == NULL) 537 goto parse_efm_error; 538 if (fmt_first == NULL) // first one 539 fmt_first = fmt_ptr; 540 else 541 fmt_last->next = fmt_ptr; 542 fmt_last = fmt_ptr; 543 544 // Isolate one part in the 'errorformat' option 545 len = efm_option_part_len(efm); 546 547 if (efm_to_regpat(efm, len, fmt_ptr, fmtstr) == FAIL) 548 goto parse_efm_error; 549 if ((fmt_ptr->prog = vim_regcomp(fmtstr, RE_MAGIC + RE_STRING)) == NULL) 550 goto parse_efm_error; 551 // Advance to next part 552 efm = skip_to_option_part(efm + len); // skip comma and spaces 553 } 554 555 if (fmt_first == NULL) // nothing found 556 emsg(_("E378: 'errorformat' contains no pattern")); 557 558 goto parse_efm_end; 559 560 parse_efm_error: 561 free_efm_list(&fmt_first); 562 563 parse_efm_end: 564 vim_free(fmtstr); 565 566 return fmt_first; 567 } 568 569 enum { 570 QF_FAIL = 0, 571 QF_OK = 1, 572 QF_END_OF_INPUT = 2, 573 QF_NOMEM = 3, 574 QF_IGNORE_LINE = 4, 575 QF_MULTISCAN = 5, 576 }; 577 578 /* 579 * State information used to parse lines and add entries to a quickfix/location 580 * list. 581 */ 582 typedef struct { 583 char_u *linebuf; 584 int linelen; 585 char_u *growbuf; 586 int growbufsiz; 587 FILE *fd; 588 typval_T *tv; 589 char_u *p_str; 590 listitem_T *p_li; 591 buf_T *buf; 592 linenr_T buflnum; 593 linenr_T lnumlast; 594 vimconv_T vc; 595 } qfstate_T; 596 597 /* 598 * Allocate more memory for the line buffer used for parsing lines. 599 */ 600 static char_u * 601 qf_grow_linebuf(qfstate_T *state, int newsz) 602 { 603 char_u *p; 604 605 // If the line exceeds LINE_MAXLEN exclude the last 606 // byte since it's not a NL character. 607 state->linelen = newsz > LINE_MAXLEN ? LINE_MAXLEN - 1 : newsz; 608 if (state->growbuf == NULL) 609 { 610 state->growbuf = alloc(state->linelen + 1); 611 if (state->growbuf == NULL) 612 return NULL; 613 state->growbufsiz = state->linelen; 614 } 615 else if (state->linelen > state->growbufsiz) 616 { 617 if ((p = vim_realloc(state->growbuf, state->linelen + 1)) == NULL) 618 return NULL; 619 state->growbuf = p; 620 state->growbufsiz = state->linelen; 621 } 622 return state->growbuf; 623 } 624 625 /* 626 * Get the next string (separated by newline) from state->p_str. 627 */ 628 static int 629 qf_get_next_str_line(qfstate_T *state) 630 { 631 // Get the next line from the supplied string 632 char_u *p_str = state->p_str; 633 char_u *p; 634 int len; 635 636 if (*p_str == NUL) // Reached the end of the string 637 return QF_END_OF_INPUT; 638 639 p = vim_strchr(p_str, '\n'); 640 if (p != NULL) 641 len = (int)(p - p_str) + 1; 642 else 643 len = (int)STRLEN(p_str); 644 645 if (len > IOSIZE - 2) 646 { 647 state->linebuf = qf_grow_linebuf(state, len); 648 if (state->linebuf == NULL) 649 return QF_NOMEM; 650 } 651 else 652 { 653 state->linebuf = IObuff; 654 state->linelen = len; 655 } 656 vim_strncpy(state->linebuf, p_str, state->linelen); 657 658 // Increment using len in order to discard the rest of the 659 // line if it exceeds LINE_MAXLEN. 660 p_str += len; 661 state->p_str = p_str; 662 663 return QF_OK; 664 } 665 666 /* 667 * Get the next string from state->p_Li. 668 */ 669 static int 670 qf_get_next_list_line(qfstate_T *state) 671 { 672 listitem_T *p_li = state->p_li; 673 int len; 674 675 while (p_li != NULL 676 && (p_li->li_tv.v_type != VAR_STRING 677 || p_li->li_tv.vval.v_string == NULL)) 678 p_li = p_li->li_next; // Skip non-string items 679 680 if (p_li == NULL) // End of the list 681 { 682 state->p_li = NULL; 683 return QF_END_OF_INPUT; 684 } 685 686 len = (int)STRLEN(p_li->li_tv.vval.v_string); 687 if (len > IOSIZE - 2) 688 { 689 state->linebuf = qf_grow_linebuf(state, len); 690 if (state->linebuf == NULL) 691 return QF_NOMEM; 692 } 693 else 694 { 695 state->linebuf = IObuff; 696 state->linelen = len; 697 } 698 699 vim_strncpy(state->linebuf, p_li->li_tv.vval.v_string, state->linelen); 700 701 state->p_li = p_li->li_next; // next item 702 return QF_OK; 703 } 704 705 /* 706 * Get the next string from state->buf. 707 */ 708 static int 709 qf_get_next_buf_line(qfstate_T *state) 710 { 711 char_u *p_buf = NULL; 712 int len; 713 714 // Get the next line from the supplied buffer 715 if (state->buflnum > state->lnumlast) 716 return QF_END_OF_INPUT; 717 718 p_buf = ml_get_buf(state->buf, state->buflnum, FALSE); 719 state->buflnum += 1; 720 721 len = (int)STRLEN(p_buf); 722 if (len > IOSIZE - 2) 723 { 724 state->linebuf = qf_grow_linebuf(state, len); 725 if (state->linebuf == NULL) 726 return QF_NOMEM; 727 } 728 else 729 { 730 state->linebuf = IObuff; 731 state->linelen = len; 732 } 733 vim_strncpy(state->linebuf, p_buf, state->linelen); 734 735 return QF_OK; 736 } 737 738 /* 739 * Get the next string from file state->fd. 740 */ 741 static int 742 qf_get_next_file_line(qfstate_T *state) 743 { 744 int discard; 745 int growbuflen; 746 747 if (fgets((char *)IObuff, IOSIZE, state->fd) == NULL) 748 return QF_END_OF_INPUT; 749 750 discard = FALSE; 751 state->linelen = (int)STRLEN(IObuff); 752 if (state->linelen == IOSIZE - 1 && !(IObuff[state->linelen - 1] == '\n')) 753 { 754 // The current line exceeds IObuff, continue reading using 755 // growbuf until EOL or LINE_MAXLEN bytes is read. 756 if (state->growbuf == NULL) 757 { 758 state->growbufsiz = 2 * (IOSIZE - 1); 759 state->growbuf = alloc(state->growbufsiz); 760 if (state->growbuf == NULL) 761 return QF_NOMEM; 762 } 763 764 // Copy the read part of the line, excluding null-terminator 765 memcpy(state->growbuf, IObuff, IOSIZE - 1); 766 growbuflen = state->linelen; 767 768 for (;;) 769 { 770 char_u *p; 771 772 if (fgets((char *)state->growbuf + growbuflen, 773 state->growbufsiz - growbuflen, state->fd) == NULL) 774 break; 775 state->linelen = (int)STRLEN(state->growbuf + growbuflen); 776 growbuflen += state->linelen; 777 if ((state->growbuf)[growbuflen - 1] == '\n') 778 break; 779 if (state->growbufsiz == LINE_MAXLEN) 780 { 781 discard = TRUE; 782 break; 783 } 784 785 state->growbufsiz = 2 * state->growbufsiz < LINE_MAXLEN 786 ? 2 * state->growbufsiz : LINE_MAXLEN; 787 if ((p = vim_realloc(state->growbuf, state->growbufsiz)) == NULL) 788 return QF_NOMEM; 789 state->growbuf = p; 790 } 791 792 while (discard) 793 { 794 // The current line is longer than LINE_MAXLEN, continue 795 // reading but discard everything until EOL or EOF is 796 // reached. 797 if (fgets((char *)IObuff, IOSIZE, state->fd) == NULL 798 || (int)STRLEN(IObuff) < IOSIZE - 1 799 || IObuff[IOSIZE - 1] == '\n') 800 break; 801 } 802 803 state->linebuf = state->growbuf; 804 state->linelen = growbuflen; 805 } 806 else 807 state->linebuf = IObuff; 808 809 // Convert a line if it contains a non-ASCII character. 810 if (state->vc.vc_type != CONV_NONE && has_non_ascii(state->linebuf)) 811 { 812 char_u *line; 813 814 line = string_convert(&state->vc, state->linebuf, &state->linelen); 815 if (line != NULL) 816 { 817 if (state->linelen < IOSIZE) 818 { 819 STRCPY(state->linebuf, line); 820 vim_free(line); 821 } 822 else 823 { 824 vim_free(state->growbuf); 825 state->linebuf = state->growbuf = line; 826 state->growbufsiz = state->linelen < LINE_MAXLEN 827 ? state->linelen : LINE_MAXLEN; 828 } 829 } 830 } 831 832 return QF_OK; 833 } 834 835 /* 836 * Get the next string from a file/buffer/list/string. 837 */ 838 static int 839 qf_get_nextline(qfstate_T *state) 840 { 841 int status = QF_FAIL; 842 843 if (state->fd == NULL) 844 { 845 if (state->tv != NULL) 846 { 847 if (state->tv->v_type == VAR_STRING) 848 // Get the next line from the supplied string 849 status = qf_get_next_str_line(state); 850 else if (state->tv->v_type == VAR_LIST) 851 // Get the next line from the supplied list 852 status = qf_get_next_list_line(state); 853 } 854 else 855 // Get the next line from the supplied buffer 856 status = qf_get_next_buf_line(state); 857 } 858 else 859 // Get the next line from the supplied file 860 status = qf_get_next_file_line(state); 861 862 if (status != QF_OK) 863 return status; 864 865 // remove newline/CR from the line 866 if (state->linelen > 0 && state->linebuf[state->linelen - 1] == '\n') 867 { 868 state->linebuf[state->linelen - 1] = NUL; 869 #ifdef USE_CRNL 870 if (state->linelen > 1 && state->linebuf[state->linelen - 2] == '\r') 871 state->linebuf[state->linelen - 2] = NUL; 872 #endif 873 } 874 875 remove_bom(state->linebuf); 876 877 return QF_OK; 878 } 879 880 typedef struct { 881 char_u *namebuf; 882 char_u *module; 883 char_u *errmsg; 884 int errmsglen; 885 long lnum; 886 int col; 887 char_u use_viscol; 888 char_u *pattern; 889 int enr; 890 int type; 891 int valid; 892 } qffields_T; 893 894 /* 895 * Parse the match for filename ('%f') pattern in regmatch. 896 * Return the matched value in "fields->namebuf". 897 */ 898 static int 899 qf_parse_fmt_f(regmatch_T *rmp, int midx, qffields_T *fields, int prefix) 900 { 901 int c; 902 903 if (rmp->startp[midx] == NULL || rmp->endp[midx] == NULL) 904 return QF_FAIL; 905 906 // Expand ~/file and $HOME/file to full path. 907 c = *rmp->endp[midx]; 908 *rmp->endp[midx] = NUL; 909 expand_env(rmp->startp[midx], fields->namebuf, CMDBUFFSIZE); 910 *rmp->endp[midx] = c; 911 912 // For separate filename patterns (%O, %P and %Q), the specified file 913 // should exist. 914 if (vim_strchr((char_u *)"OPQ", prefix) != NULL 915 && mch_getperm(fields->namebuf) == -1) 916 return QF_FAIL; 917 918 return QF_OK; 919 } 920 921 /* 922 * Parse the match for error number ('%n') pattern in regmatch. 923 * Return the matched value in "fields->enr". 924 */ 925 static int 926 qf_parse_fmt_n(regmatch_T *rmp, int midx, qffields_T *fields) 927 { 928 if (rmp->startp[midx] == NULL) 929 return QF_FAIL; 930 fields->enr = (int)atol((char *)rmp->startp[midx]); 931 return QF_OK; 932 } 933 934 /* 935 * Parse the match for line number (%l') pattern in regmatch. 936 * Return the matched value in "fields->lnum". 937 */ 938 static int 939 qf_parse_fmt_l(regmatch_T *rmp, int midx, qffields_T *fields) 940 { 941 if (rmp->startp[midx] == NULL) 942 return QF_FAIL; 943 fields->lnum = atol((char *)rmp->startp[midx]); 944 return QF_OK; 945 } 946 947 /* 948 * Parse the match for column number ('%c') pattern in regmatch. 949 * Return the matched value in "fields->col". 950 */ 951 static int 952 qf_parse_fmt_c(regmatch_T *rmp, int midx, qffields_T *fields) 953 { 954 if (rmp->startp[midx] == NULL) 955 return QF_FAIL; 956 fields->col = (int)atol((char *)rmp->startp[midx]); 957 return QF_OK; 958 } 959 960 /* 961 * Parse the match for error type ('%t') pattern in regmatch. 962 * Return the matched value in "fields->type". 963 */ 964 static int 965 qf_parse_fmt_t(regmatch_T *rmp, int midx, qffields_T *fields) 966 { 967 if (rmp->startp[midx] == NULL) 968 return QF_FAIL; 969 fields->type = *rmp->startp[midx]; 970 return QF_OK; 971 } 972 973 /* 974 * Parse the match for '%+' format pattern. The whole matching line is included 975 * in the error string. Return the matched line in "fields->errmsg". 976 */ 977 static int 978 qf_parse_fmt_plus(char_u *linebuf, int linelen, qffields_T *fields) 979 { 980 char_u *p; 981 982 if (linelen >= fields->errmsglen) 983 { 984 // linelen + null terminator 985 if ((p = vim_realloc(fields->errmsg, linelen + 1)) == NULL) 986 return QF_NOMEM; 987 fields->errmsg = p; 988 fields->errmsglen = linelen + 1; 989 } 990 vim_strncpy(fields->errmsg, linebuf, linelen); 991 return QF_OK; 992 } 993 994 /* 995 * Parse the match for error message ('%m') pattern in regmatch. 996 * Return the matched value in "fields->errmsg". 997 */ 998 static int 999 qf_parse_fmt_m(regmatch_T *rmp, int midx, qffields_T *fields) 1000 { 1001 char_u *p; 1002 int len; 1003 1004 if (rmp->startp[midx] == NULL || rmp->endp[midx] == NULL) 1005 return QF_FAIL; 1006 len = (int)(rmp->endp[midx] - rmp->startp[midx]); 1007 if (len >= fields->errmsglen) 1008 { 1009 // len + null terminator 1010 if ((p = vim_realloc(fields->errmsg, len + 1)) == NULL) 1011 return QF_NOMEM; 1012 fields->errmsg = p; 1013 fields->errmsglen = len + 1; 1014 } 1015 vim_strncpy(fields->errmsg, rmp->startp[midx], len); 1016 return QF_OK; 1017 } 1018 1019 /* 1020 * Parse the match for rest of a single-line file message ('%r') pattern. 1021 * Return the matched value in "tail". 1022 */ 1023 static int 1024 qf_parse_fmt_r(regmatch_T *rmp, int midx, char_u **tail) 1025 { 1026 if (rmp->startp[midx] == NULL) 1027 return QF_FAIL; 1028 *tail = rmp->startp[midx]; 1029 return QF_OK; 1030 } 1031 1032 /* 1033 * Parse the match for the pointer line ('%p') pattern in regmatch. 1034 * Return the matched value in "fields->col". 1035 */ 1036 static int 1037 qf_parse_fmt_p(regmatch_T *rmp, int midx, qffields_T *fields) 1038 { 1039 char_u *match_ptr; 1040 1041 if (rmp->startp[midx] == NULL || rmp->endp[midx] == NULL) 1042 return QF_FAIL; 1043 fields->col = 0; 1044 for (match_ptr = rmp->startp[midx]; match_ptr != rmp->endp[midx]; 1045 ++match_ptr) 1046 { 1047 ++fields->col; 1048 if (*match_ptr == TAB) 1049 { 1050 fields->col += 7; 1051 fields->col -= fields->col % 8; 1052 } 1053 } 1054 ++fields->col; 1055 fields->use_viscol = TRUE; 1056 return QF_OK; 1057 } 1058 1059 /* 1060 * Parse the match for the virtual column number ('%v') pattern in regmatch. 1061 * Return the matched value in "fields->col". 1062 */ 1063 static int 1064 qf_parse_fmt_v(regmatch_T *rmp, int midx, qffields_T *fields) 1065 { 1066 if (rmp->startp[midx] == NULL) 1067 return QF_FAIL; 1068 fields->col = (int)atol((char *)rmp->startp[midx]); 1069 fields->use_viscol = TRUE; 1070 return QF_OK; 1071 } 1072 1073 /* 1074 * Parse the match for the search text ('%s') pattern in regmatch. 1075 * Return the matched value in "fields->pattern". 1076 */ 1077 static int 1078 qf_parse_fmt_s(regmatch_T *rmp, int midx, qffields_T *fields) 1079 { 1080 int len; 1081 1082 if (rmp->startp[midx] == NULL || rmp->endp[midx] == NULL) 1083 return QF_FAIL; 1084 len = (int)(rmp->endp[midx] - rmp->startp[midx]); 1085 if (len > CMDBUFFSIZE - 5) 1086 len = CMDBUFFSIZE - 5; 1087 STRCPY(fields->pattern, "^\\V"); 1088 STRNCAT(fields->pattern, rmp->startp[midx], len); 1089 fields->pattern[len + 3] = '\\'; 1090 fields->pattern[len + 4] = '$'; 1091 fields->pattern[len + 5] = NUL; 1092 return QF_OK; 1093 } 1094 1095 /* 1096 * Parse the match for the module ('%o') pattern in regmatch. 1097 * Return the matched value in "fields->module". 1098 */ 1099 static int 1100 qf_parse_fmt_o(regmatch_T *rmp, int midx, qffields_T *fields) 1101 { 1102 int len; 1103 1104 if (rmp->startp[midx] == NULL || rmp->endp[midx] == NULL) 1105 return QF_FAIL; 1106 len = (int)(rmp->endp[midx] - rmp->startp[midx]); 1107 if (len > CMDBUFFSIZE) 1108 len = CMDBUFFSIZE; 1109 STRNCAT(fields->module, rmp->startp[midx], len); 1110 return QF_OK; 1111 } 1112 1113 /* 1114 * 'errorformat' format pattern parser functions. 1115 * The '%f' and '%r' formats are parsed differently from other formats. 1116 * See qf_parse_match() for details. 1117 */ 1118 static int (*qf_parse_fmt[FMT_PATTERNS])(regmatch_T *, int, qffields_T *) = 1119 { 1120 NULL, 1121 qf_parse_fmt_n, 1122 qf_parse_fmt_l, 1123 qf_parse_fmt_c, 1124 qf_parse_fmt_t, 1125 qf_parse_fmt_m, 1126 NULL, 1127 qf_parse_fmt_p, 1128 qf_parse_fmt_v, 1129 qf_parse_fmt_s, 1130 qf_parse_fmt_o 1131 }; 1132 1133 /* 1134 * Parse the error format pattern matches in "regmatch" and set the values in 1135 * "fields". fmt_ptr contains the 'efm' format specifiers/prefixes that have a 1136 * match. Returns QF_OK if all the matches are successfully parsed. On 1137 * failure, returns QF_FAIL or QF_NOMEM. 1138 */ 1139 static int 1140 qf_parse_match( 1141 char_u *linebuf, 1142 int linelen, 1143 efm_T *fmt_ptr, 1144 regmatch_T *regmatch, 1145 qffields_T *fields, 1146 int qf_multiline, 1147 int qf_multiscan, 1148 char_u **tail) 1149 { 1150 int idx = fmt_ptr->prefix; 1151 int i; 1152 int midx; 1153 int status; 1154 1155 if ((idx == 'C' || idx == 'Z') && !qf_multiline) 1156 return QF_FAIL; 1157 if (vim_strchr((char_u *)"EWI", idx) != NULL) 1158 fields->type = idx; 1159 else 1160 fields->type = 0; 1161 1162 // Extract error message data from matched line. 1163 // We check for an actual submatch, because "\[" and "\]" in 1164 // the 'errorformat' may cause the wrong submatch to be used. 1165 for (i = 0; i < FMT_PATTERNS; i++) 1166 { 1167 status = QF_OK; 1168 midx = (int)fmt_ptr->addr[i]; 1169 if (i == 0 && midx > 0) // %f 1170 status = qf_parse_fmt_f(regmatch, midx, fields, idx); 1171 else if (i == 5) 1172 { 1173 if (fmt_ptr->flags == '+' && !qf_multiscan) // %+ 1174 status = qf_parse_fmt_plus(linebuf, linelen, fields); 1175 else if (midx > 0) // %m 1176 status = qf_parse_fmt_m(regmatch, midx, fields); 1177 } 1178 else if (i == 6 && midx > 0) // %r 1179 status = qf_parse_fmt_r(regmatch, midx, tail); 1180 else if (midx > 0) // others 1181 status = (qf_parse_fmt[i])(regmatch, midx, fields); 1182 1183 if (status != QF_OK) 1184 return status; 1185 } 1186 1187 return QF_OK; 1188 } 1189 1190 /* 1191 * Parse an error line in 'linebuf' using a single error format string in 1192 * 'fmt_ptr->prog' and return the matching values in 'fields'. 1193 * Returns QF_OK if the efm format matches completely and the fields are 1194 * successfully copied. Otherwise returns QF_FAIL or QF_NOMEM. 1195 */ 1196 static int 1197 qf_parse_get_fields( 1198 char_u *linebuf, 1199 int linelen, 1200 efm_T *fmt_ptr, 1201 qffields_T *fields, 1202 int qf_multiline, 1203 int qf_multiscan, 1204 char_u **tail) 1205 { 1206 regmatch_T regmatch; 1207 int status = QF_FAIL; 1208 int r; 1209 1210 if (qf_multiscan && 1211 vim_strchr((char_u *)"OPQ", fmt_ptr->prefix) == NULL) 1212 return QF_FAIL; 1213 1214 fields->namebuf[0] = NUL; 1215 fields->module[0] = NUL; 1216 fields->pattern[0] = NUL; 1217 if (!qf_multiscan) 1218 fields->errmsg[0] = NUL; 1219 fields->lnum = 0; 1220 fields->col = 0; 1221 fields->use_viscol = FALSE; 1222 fields->enr = -1; 1223 fields->type = 0; 1224 *tail = NULL; 1225 1226 // Always ignore case when looking for a matching error. 1227 regmatch.rm_ic = TRUE; 1228 regmatch.regprog = fmt_ptr->prog; 1229 r = vim_regexec(®match, linebuf, (colnr_T)0); 1230 fmt_ptr->prog = regmatch.regprog; 1231 if (r) 1232 status = qf_parse_match(linebuf, linelen, fmt_ptr, ®match, 1233 fields, qf_multiline, qf_multiscan, tail); 1234 1235 return status; 1236 } 1237 1238 /* 1239 * Parse directory error format prefixes (%D and %X). 1240 * Push and pop directories from the directory stack when scanning directory 1241 * names. 1242 */ 1243 static int 1244 qf_parse_dir_pfx(int idx, qffields_T *fields, qf_list_T *qfl) 1245 { 1246 if (idx == 'D') // enter directory 1247 { 1248 if (*fields->namebuf == NUL) 1249 { 1250 emsg(_("E379: Missing or empty directory name")); 1251 return QF_FAIL; 1252 } 1253 qfl->qf_directory = 1254 qf_push_dir(fields->namebuf, &qfl->qf_dir_stack, FALSE); 1255 if (qfl->qf_directory == NULL) 1256 return QF_FAIL; 1257 } 1258 else if (idx == 'X') // leave directory 1259 qfl->qf_directory = qf_pop_dir(&qfl->qf_dir_stack); 1260 1261 return QF_OK; 1262 } 1263 1264 /* 1265 * Parse global file name error format prefixes (%O, %P and %Q). 1266 */ 1267 static int 1268 qf_parse_file_pfx( 1269 int idx, 1270 qffields_T *fields, 1271 qf_list_T *qfl, 1272 char_u *tail) 1273 { 1274 fields->valid = FALSE; 1275 if (*fields->namebuf == NUL || mch_getperm(fields->namebuf) >= 0) 1276 { 1277 if (*fields->namebuf && idx == 'P') 1278 qfl->qf_currfile = 1279 qf_push_dir(fields->namebuf, &qfl->qf_file_stack, TRUE); 1280 else if (idx == 'Q') 1281 qfl->qf_currfile = qf_pop_dir(&qfl->qf_file_stack); 1282 *fields->namebuf = NUL; 1283 if (tail && *tail) 1284 { 1285 STRMOVE(IObuff, skipwhite(tail)); 1286 qfl->qf_multiscan = TRUE; 1287 return QF_MULTISCAN; 1288 } 1289 } 1290 1291 return QF_OK; 1292 } 1293 1294 /* 1295 * Parse a non-error line (a line which doesn't match any of the error 1296 * format in 'efm'). 1297 */ 1298 static int 1299 qf_parse_line_nomatch(char_u *linebuf, int linelen, qffields_T *fields) 1300 { 1301 char_u *p; 1302 1303 fields->namebuf[0] = NUL; // no match found, remove file name 1304 fields->lnum = 0; // don't jump to this line 1305 fields->valid = FALSE; 1306 if (linelen >= fields->errmsglen) 1307 { 1308 // linelen + null terminator 1309 if ((p = vim_realloc(fields->errmsg, linelen + 1)) == NULL) 1310 return QF_NOMEM; 1311 fields->errmsg = p; 1312 fields->errmsglen = linelen + 1; 1313 } 1314 // copy whole line to error message 1315 vim_strncpy(fields->errmsg, linebuf, linelen); 1316 1317 return QF_OK; 1318 } 1319 1320 /* 1321 * Parse multi-line error format prefixes (%C and %Z) 1322 */ 1323 static int 1324 qf_parse_multiline_pfx( 1325 int idx, 1326 qf_list_T *qfl, 1327 qffields_T *fields) 1328 { 1329 char_u *ptr; 1330 int len; 1331 1332 if (!qfl->qf_multiignore) 1333 { 1334 qfline_T *qfprev = qfl->qf_last; 1335 1336 if (qfprev == NULL) 1337 return QF_FAIL; 1338 if (*fields->errmsg && !qfl->qf_multiignore) 1339 { 1340 len = (int)STRLEN(qfprev->qf_text); 1341 if ((ptr = alloc((unsigned)(len + STRLEN(fields->errmsg) + 2))) 1342 == NULL) 1343 return QF_FAIL; 1344 STRCPY(ptr, qfprev->qf_text); 1345 vim_free(qfprev->qf_text); 1346 qfprev->qf_text = ptr; 1347 *(ptr += len) = '\n'; 1348 STRCPY(++ptr, fields->errmsg); 1349 } 1350 if (qfprev->qf_nr == -1) 1351 qfprev->qf_nr = fields->enr; 1352 if (vim_isprintc(fields->type) && !qfprev->qf_type) 1353 // only printable chars allowed 1354 qfprev->qf_type = fields->type; 1355 1356 if (!qfprev->qf_lnum) 1357 qfprev->qf_lnum = fields->lnum; 1358 if (!qfprev->qf_col) 1359 qfprev->qf_col = fields->col; 1360 qfprev->qf_viscol = fields->use_viscol; 1361 if (!qfprev->qf_fnum) 1362 qfprev->qf_fnum = qf_get_fnum(qfl, 1363 qfl->qf_directory, 1364 *fields->namebuf || qfl->qf_directory != NULL 1365 ? fields->namebuf 1366 : qfl->qf_currfile != NULL && fields->valid 1367 ? qfl->qf_currfile : 0); 1368 } 1369 if (idx == 'Z') 1370 qfl->qf_multiline = qfl->qf_multiignore = FALSE; 1371 line_breakcheck(); 1372 1373 return QF_IGNORE_LINE; 1374 } 1375 1376 /* 1377 * Parse a line and get the quickfix fields. 1378 * Return the QF_ status. 1379 */ 1380 static int 1381 qf_parse_line( 1382 qf_list_T *qfl, 1383 char_u *linebuf, 1384 int linelen, 1385 efm_T *fmt_first, 1386 qffields_T *fields) 1387 { 1388 efm_T *fmt_ptr; 1389 int idx = 0; 1390 char_u *tail = NULL; 1391 int status; 1392 1393 restofline: 1394 // If there was no %> item start at the first pattern 1395 if (fmt_start == NULL) 1396 fmt_ptr = fmt_first; 1397 else 1398 { 1399 // Otherwise start from the last used pattern 1400 fmt_ptr = fmt_start; 1401 fmt_start = NULL; 1402 } 1403 1404 // Try to match each part of 'errorformat' until we find a complete 1405 // match or no match. 1406 fields->valid = TRUE; 1407 for ( ; fmt_ptr != NULL; fmt_ptr = fmt_ptr->next) 1408 { 1409 idx = fmt_ptr->prefix; 1410 status = qf_parse_get_fields(linebuf, linelen, fmt_ptr, fields, 1411 qfl->qf_multiline, qfl->qf_multiscan, &tail); 1412 if (status == QF_NOMEM) 1413 return status; 1414 if (status == QF_OK) 1415 break; 1416 } 1417 qfl->qf_multiscan = FALSE; 1418 1419 if (fmt_ptr == NULL || idx == 'D' || idx == 'X') 1420 { 1421 if (fmt_ptr != NULL) 1422 { 1423 // 'D' and 'X' directory specifiers 1424 status = qf_parse_dir_pfx(idx, fields, qfl); 1425 if (status != QF_OK) 1426 return status; 1427 } 1428 1429 status = qf_parse_line_nomatch(linebuf, linelen, fields); 1430 if (status != QF_OK) 1431 return status; 1432 1433 if (fmt_ptr == NULL) 1434 qfl->qf_multiline = qfl->qf_multiignore = FALSE; 1435 } 1436 else if (fmt_ptr != NULL) 1437 { 1438 // honor %> item 1439 if (fmt_ptr->conthere) 1440 fmt_start = fmt_ptr; 1441 1442 if (vim_strchr((char_u *)"AEWI", idx) != NULL) 1443 { 1444 qfl->qf_multiline = TRUE; // start of a multi-line message 1445 qfl->qf_multiignore = FALSE;// reset continuation 1446 } 1447 else if (vim_strchr((char_u *)"CZ", idx) != NULL) 1448 { // continuation of multi-line msg 1449 status = qf_parse_multiline_pfx(idx, qfl, fields); 1450 if (status != QF_OK) 1451 return status; 1452 } 1453 else if (vim_strchr((char_u *)"OPQ", idx) != NULL) 1454 { // global file names 1455 status = qf_parse_file_pfx(idx, fields, qfl, tail); 1456 if (status == QF_MULTISCAN) 1457 goto restofline; 1458 } 1459 if (fmt_ptr->flags == '-') // generally exclude this line 1460 { 1461 if (qfl->qf_multiline) 1462 // also exclude continuation lines 1463 qfl->qf_multiignore = TRUE; 1464 return QF_IGNORE_LINE; 1465 } 1466 } 1467 1468 return QF_OK; 1469 } 1470 1471 /* 1472 * Returns TRUE if the specified quickfix/location stack is empty 1473 */ 1474 static int 1475 qf_stack_empty(qf_info_T *qi) 1476 { 1477 return qi == NULL || qi->qf_listcount <= 0; 1478 } 1479 1480 /* 1481 * Returns TRUE if the specified quickfix/location list is empty. 1482 */ 1483 static int 1484 qf_list_empty(qf_list_T *qfl) 1485 { 1486 return qfl == NULL || qfl->qf_count <= 0; 1487 } 1488 1489 /* 1490 * Return a pointer to a list in the specified quickfix stack 1491 */ 1492 static qf_list_T * 1493 qf_get_list(qf_info_T *qi, int idx) 1494 { 1495 return &qi->qf_lists[idx]; 1496 } 1497 1498 /* 1499 * Allocate the fields used for parsing lines and populating a quickfix list. 1500 */ 1501 static int 1502 qf_alloc_fields(qffields_T *pfields) 1503 { 1504 pfields->namebuf = alloc_id(CMDBUFFSIZE + 1, aid_qf_namebuf); 1505 pfields->module = alloc_id(CMDBUFFSIZE + 1, aid_qf_module); 1506 pfields->errmsglen = CMDBUFFSIZE + 1; 1507 pfields->errmsg = alloc_id(pfields->errmsglen, aid_qf_errmsg); 1508 pfields->pattern = alloc_id(CMDBUFFSIZE + 1, aid_qf_pattern); 1509 if (pfields->namebuf == NULL || pfields->errmsg == NULL 1510 || pfields->pattern == NULL || pfields->module == NULL) 1511 return FAIL; 1512 1513 return OK; 1514 } 1515 1516 /* 1517 * Free the fields used for parsing lines and populating a quickfix list. 1518 */ 1519 static void 1520 qf_free_fields(qffields_T *pfields) 1521 { 1522 vim_free(pfields->namebuf); 1523 vim_free(pfields->module); 1524 vim_free(pfields->errmsg); 1525 vim_free(pfields->pattern); 1526 } 1527 1528 /* 1529 * Setup the state information used for parsing lines and populating a 1530 * quickfix list. 1531 */ 1532 static int 1533 qf_setup_state( 1534 qfstate_T *pstate, 1535 char_u *enc, 1536 char_u *efile, 1537 typval_T *tv, 1538 buf_T *buf, 1539 linenr_T lnumfirst, 1540 linenr_T lnumlast) 1541 { 1542 pstate->vc.vc_type = CONV_NONE; 1543 if (enc != NULL && *enc != NUL) 1544 convert_setup(&pstate->vc, enc, p_enc); 1545 1546 if (efile != NULL && (pstate->fd = mch_fopen((char *)efile, "r")) == NULL) 1547 { 1548 semsg(_(e_openerrf), efile); 1549 return FAIL; 1550 } 1551 1552 if (tv != NULL) 1553 { 1554 if (tv->v_type == VAR_STRING) 1555 pstate->p_str = tv->vval.v_string; 1556 else if (tv->v_type == VAR_LIST) 1557 pstate->p_li = tv->vval.v_list->lv_first; 1558 pstate->tv = tv; 1559 } 1560 pstate->buf = buf; 1561 pstate->buflnum = lnumfirst; 1562 pstate->lnumlast = lnumlast; 1563 1564 return OK; 1565 } 1566 1567 /* 1568 * Cleanup the state information used for parsing lines and populating a 1569 * quickfix list. 1570 */ 1571 static void 1572 qf_cleanup_state(qfstate_T *pstate) 1573 { 1574 if (pstate->fd != NULL) 1575 fclose(pstate->fd); 1576 1577 vim_free(pstate->growbuf); 1578 if (pstate->vc.vc_type != CONV_NONE) 1579 convert_setup(&pstate->vc, NULL, NULL); 1580 } 1581 1582 /* 1583 * Read the errorfile "efile" into memory, line by line, building the error 1584 * list. 1585 * Alternative: when "efile" is NULL read errors from buffer "buf". 1586 * Alternative: when "tv" is not NULL get errors from the string or list. 1587 * Always use 'errorformat' from "buf" if there is a local value. 1588 * Then "lnumfirst" and "lnumlast" specify the range of lines to use. 1589 * Set the title of the list to "qf_title". 1590 * Return -1 for error, number of errors for success. 1591 */ 1592 static int 1593 qf_init_ext( 1594 qf_info_T *qi, 1595 int qf_idx, 1596 char_u *efile, 1597 buf_T *buf, 1598 typval_T *tv, 1599 char_u *errorformat, 1600 int newlist, // TRUE: start a new error list 1601 linenr_T lnumfirst, // first line number to use 1602 linenr_T lnumlast, // last line number to use 1603 char_u *qf_title, 1604 char_u *enc) 1605 { 1606 qf_list_T *qfl; 1607 qfstate_T state; 1608 qffields_T fields; 1609 qfline_T *old_last = NULL; 1610 int adding = FALSE; 1611 static efm_T *fmt_first = NULL; 1612 char_u *efm; 1613 static char_u *last_efm = NULL; 1614 int retval = -1; // default: return error flag 1615 int status; 1616 1617 // Do not used the cached buffer, it may have been wiped out. 1618 VIM_CLEAR(qf_last_bufname); 1619 1620 vim_memset(&state, 0, sizeof(state)); 1621 vim_memset(&fields, 0, sizeof(fields)); 1622 if ((qf_alloc_fields(&fields) == FAIL) || 1623 (qf_setup_state(&state, enc, efile, tv, buf, 1624 lnumfirst, lnumlast) == FAIL)) 1625 goto qf_init_end; 1626 1627 if (newlist || qf_idx == qi->qf_listcount) 1628 { 1629 // make place for a new list 1630 qf_new_list(qi, qf_title); 1631 qf_idx = qi->qf_curlist; 1632 qfl = qf_get_list(qi, qf_idx); 1633 } 1634 else 1635 { 1636 // Adding to existing list, use last entry. 1637 adding = TRUE; 1638 qfl = qf_get_list(qi, qf_idx); 1639 if (!qf_list_empty(qfl)) 1640 old_last = qfl->qf_last; 1641 } 1642 1643 // Use the local value of 'errorformat' if it's set. 1644 if (errorformat == p_efm && tv == NULL && *buf->b_p_efm != NUL) 1645 efm = buf->b_p_efm; 1646 else 1647 efm = errorformat; 1648 1649 // If the errorformat didn't change between calls, then reuse the 1650 // previously parsed values. 1651 if (last_efm == NULL || (STRCMP(last_efm, efm) != 0)) 1652 { 1653 // free the previously parsed data 1654 VIM_CLEAR(last_efm); 1655 free_efm_list(&fmt_first); 1656 1657 // parse the current 'efm' 1658 fmt_first = parse_efm_option(efm); 1659 if (fmt_first != NULL) 1660 last_efm = vim_strsave(efm); 1661 } 1662 1663 if (fmt_first == NULL) // nothing found 1664 goto error2; 1665 1666 // got_int is reset here, because it was probably set when killing the 1667 // ":make" command, but we still want to read the errorfile then. 1668 got_int = FALSE; 1669 1670 // Read the lines in the error file one by one. 1671 // Try to recognize one of the error formats in each line. 1672 while (!got_int) 1673 { 1674 // Get the next line from a file/buffer/list/string 1675 status = qf_get_nextline(&state); 1676 if (status == QF_NOMEM) // memory alloc failure 1677 goto qf_init_end; 1678 if (status == QF_END_OF_INPUT) // end of input 1679 break; 1680 1681 status = qf_parse_line(qfl, state.linebuf, state.linelen, 1682 fmt_first, &fields); 1683 if (status == QF_FAIL) 1684 goto error2; 1685 if (status == QF_NOMEM) 1686 goto qf_init_end; 1687 if (status == QF_IGNORE_LINE) 1688 continue; 1689 1690 if (qf_add_entry(qfl, 1691 qfl->qf_directory, 1692 (*fields.namebuf || qfl->qf_directory != NULL) 1693 ? fields.namebuf 1694 : ((qfl->qf_currfile != NULL && fields.valid) 1695 ? qfl->qf_currfile : (char_u *)NULL), 1696 fields.module, 1697 0, 1698 fields.errmsg, 1699 fields.lnum, 1700 fields.col, 1701 fields.use_viscol, 1702 fields.pattern, 1703 fields.enr, 1704 fields.type, 1705 fields.valid) == FAIL) 1706 goto error2; 1707 line_breakcheck(); 1708 } 1709 if (state.fd == NULL || !ferror(state.fd)) 1710 { 1711 if (qfl->qf_index == 0) 1712 { 1713 // no valid entry found 1714 qfl->qf_ptr = qfl->qf_start; 1715 qfl->qf_index = 1; 1716 qfl->qf_nonevalid = TRUE; 1717 } 1718 else 1719 { 1720 qfl->qf_nonevalid = FALSE; 1721 if (qfl->qf_ptr == NULL) 1722 qfl->qf_ptr = qfl->qf_start; 1723 } 1724 // return number of matches 1725 retval = qfl->qf_count; 1726 goto qf_init_end; 1727 } 1728 emsg(_(e_readerrf)); 1729 error2: 1730 if (!adding) 1731 { 1732 // Error when creating a new list. Free the new list 1733 qf_free(qfl); 1734 qi->qf_listcount--; 1735 if (qi->qf_curlist > 0) 1736 --qi->qf_curlist; 1737 } 1738 qf_init_end: 1739 if (qf_idx == qi->qf_curlist) 1740 qf_update_buffer(qi, old_last); 1741 qf_cleanup_state(&state); 1742 qf_free_fields(&fields); 1743 1744 return retval; 1745 } 1746 1747 /* 1748 * Read the errorfile "efile" into memory, line by line, building the error 1749 * list. Set the error list's title to qf_title. 1750 * Return -1 for error, number of errors for success. 1751 */ 1752 int 1753 qf_init(win_T *wp, 1754 char_u *efile, 1755 char_u *errorformat, 1756 int newlist, // TRUE: start a new error list 1757 char_u *qf_title, 1758 char_u *enc) 1759 { 1760 qf_info_T *qi = &ql_info; 1761 1762 if (wp != NULL) 1763 { 1764 qi = ll_get_or_alloc_list(wp); 1765 if (qi == NULL) 1766 return FAIL; 1767 } 1768 1769 return qf_init_ext(qi, qi->qf_curlist, efile, curbuf, NULL, errorformat, 1770 newlist, (linenr_T)0, (linenr_T)0, qf_title, enc); 1771 } 1772 1773 /* 1774 * Set the title of the specified quickfix list. Frees the previous title. 1775 * Prepends ':' to the title. 1776 */ 1777 static void 1778 qf_store_title(qf_list_T *qfl, char_u *title) 1779 { 1780 VIM_CLEAR(qfl->qf_title); 1781 1782 if (title != NULL) 1783 { 1784 char_u *p = alloc((int)STRLEN(title) + 2); 1785 1786 qfl->qf_title = p; 1787 if (p != NULL) 1788 STRCPY(p, title); 1789 } 1790 } 1791 1792 /* 1793 * The title of a quickfix/location list is set, by default, to the command 1794 * that created the quickfix list with the ":" prefix. 1795 * Create a quickfix list title string by prepending ":" to a user command. 1796 * Returns a pointer to a static buffer with the title. 1797 */ 1798 static char_u * 1799 qf_cmdtitle(char_u *cmd) 1800 { 1801 static char_u qftitle_str[IOSIZE]; 1802 1803 vim_snprintf((char *)qftitle_str, IOSIZE, ":%s", (char *)cmd); 1804 return qftitle_str; 1805 } 1806 1807 /* 1808 * Return a pointer to the current list in the specified quickfix stack 1809 */ 1810 static qf_list_T * 1811 qf_get_curlist(qf_info_T *qi) 1812 { 1813 return qf_get_list(qi, qi->qf_curlist); 1814 } 1815 1816 /* 1817 * Prepare for adding a new quickfix list. If the current list is in the 1818 * middle of the stack, then all the following lists are freed and then 1819 * the new list is added. 1820 */ 1821 static void 1822 qf_new_list(qf_info_T *qi, char_u *qf_title) 1823 { 1824 int i; 1825 qf_list_T *qfl; 1826 1827 // If the current entry is not the last entry, delete entries beyond 1828 // the current entry. This makes it possible to browse in a tree-like 1829 // way with ":grep'. 1830 while (qi->qf_listcount > qi->qf_curlist + 1) 1831 qf_free(&qi->qf_lists[--qi->qf_listcount]); 1832 1833 // When the stack is full, remove to oldest entry 1834 // Otherwise, add a new entry. 1835 if (qi->qf_listcount == LISTCOUNT) 1836 { 1837 qf_free(&qi->qf_lists[0]); 1838 for (i = 1; i < LISTCOUNT; ++i) 1839 qi->qf_lists[i - 1] = qi->qf_lists[i]; 1840 qi->qf_curlist = LISTCOUNT - 1; 1841 } 1842 else 1843 qi->qf_curlist = qi->qf_listcount++; 1844 qfl = qf_get_curlist(qi); 1845 vim_memset(qfl, 0, (size_t)(sizeof(qf_list_T))); 1846 qf_store_title(qfl, qf_title); 1847 qfl->qfl_type = qi->qfl_type; 1848 qfl->qf_id = ++last_qf_id; 1849 } 1850 1851 /* 1852 * Queue location list stack delete request. 1853 */ 1854 static void 1855 locstack_queue_delreq(qf_info_T *qi) 1856 { 1857 qf_delq_T *q; 1858 1859 q = (qf_delq_T *)alloc((unsigned)sizeof(qf_delq_T)); 1860 if (q != NULL) 1861 { 1862 q->qi = qi; 1863 q->next = qf_delq_head; 1864 qf_delq_head = q; 1865 } 1866 } 1867 1868 /* 1869 * Return the global quickfix stack window buffer number. 1870 */ 1871 int 1872 qf_stack_get_bufnr(void) 1873 { 1874 return ql_info.qf_bufnr; 1875 } 1876 1877 /* 1878 * Wipe the quickfix window buffer (if present) for the specified 1879 * quickfix/location list. 1880 */ 1881 static void 1882 wipe_qf_buffer(qf_info_T *qi) 1883 { 1884 buf_T *qfbuf; 1885 1886 if (qi->qf_bufnr != INVALID_QFBUFNR) 1887 { 1888 qfbuf = buflist_findnr(qi->qf_bufnr); 1889 if (qfbuf != NULL && qfbuf->b_nwindows == 0) 1890 { 1891 // If the quickfix buffer is not loaded in any window, then 1892 // wipe the buffer. 1893 close_buffer(NULL, qfbuf, DOBUF_WIPE, FALSE); 1894 qi->qf_bufnr = INVALID_QFBUFNR; 1895 } 1896 } 1897 } 1898 1899 /* 1900 * Free a location list stack 1901 */ 1902 static void 1903 ll_free_all(qf_info_T **pqi) 1904 { 1905 int i; 1906 qf_info_T *qi; 1907 1908 qi = *pqi; 1909 if (qi == NULL) 1910 return; 1911 *pqi = NULL; // Remove reference to this list 1912 1913 // If the location list is still in use, then queue the delete request 1914 // to be processed later. 1915 if (quickfix_busy > 0) 1916 { 1917 locstack_queue_delreq(qi); 1918 return; 1919 } 1920 1921 qi->qf_refcount--; 1922 if (qi->qf_refcount < 1) 1923 { 1924 // No references to this location list. 1925 // If the quickfix window buffer is loaded, then wipe it 1926 wipe_qf_buffer(qi); 1927 1928 for (i = 0; i < qi->qf_listcount; ++i) 1929 qf_free(qf_get_list(qi, i)); 1930 vim_free(qi); 1931 } 1932 } 1933 1934 /* 1935 * Free all the quickfix/location lists in the stack. 1936 */ 1937 void 1938 qf_free_all(win_T *wp) 1939 { 1940 int i; 1941 qf_info_T *qi = &ql_info; 1942 1943 if (wp != NULL) 1944 { 1945 // location list 1946 ll_free_all(&wp->w_llist); 1947 ll_free_all(&wp->w_llist_ref); 1948 } 1949 else 1950 // quickfix list 1951 for (i = 0; i < qi->qf_listcount; ++i) 1952 qf_free(qf_get_list(qi, i)); 1953 } 1954 1955 /* 1956 * Delay freeing of location list stacks when the quickfix code is running. 1957 * Used to avoid problems with autocmds freeing location list stacks when the 1958 * quickfix code is still referencing the stack. 1959 * Must always call decr_quickfix_busy() exactly once after this. 1960 */ 1961 static void 1962 incr_quickfix_busy(void) 1963 { 1964 quickfix_busy++; 1965 } 1966 1967 /* 1968 * Safe to free location list stacks. Process any delayed delete requests. 1969 */ 1970 static void 1971 decr_quickfix_busy(void) 1972 { 1973 if (--quickfix_busy == 0) 1974 { 1975 // No longer referencing the location lists. Process all the pending 1976 // delete requests. 1977 while (qf_delq_head != NULL) 1978 { 1979 qf_delq_T *q = qf_delq_head; 1980 1981 qf_delq_head = q->next; 1982 ll_free_all(&q->qi); 1983 vim_free(q); 1984 } 1985 } 1986 #ifdef ABORT_ON_INTERNAL_ERROR 1987 if (quickfix_busy < 0) 1988 { 1989 emsg("quickfix_busy has become negative"); 1990 abort(); 1991 } 1992 #endif 1993 } 1994 1995 #if defined(EXITFREE) || defined(PROTO) 1996 void 1997 check_quickfix_busy(void) 1998 { 1999 if (quickfix_busy != 0) 2000 { 2001 semsg("quickfix_busy not zero on exit: %ld", (long)quickfix_busy); 2002 # ifdef ABORT_ON_INTERNAL_ERROR 2003 abort(); 2004 # endif 2005 } 2006 } 2007 #endif 2008 2009 /* 2010 * Add an entry to the end of the list of errors. 2011 * Returns OK or FAIL. 2012 */ 2013 static int 2014 qf_add_entry( 2015 qf_list_T *qfl, // quickfix list entry 2016 char_u *dir, // optional directory name 2017 char_u *fname, // file name or NULL 2018 char_u *module, // module name or NULL 2019 int bufnum, // buffer number or zero 2020 char_u *mesg, // message 2021 long lnum, // line number 2022 int col, // column 2023 int vis_col, // using visual column 2024 char_u *pattern, // search pattern 2025 int nr, // error number 2026 int type, // type character 2027 int valid) // valid entry 2028 { 2029 qfline_T *qfp; 2030 qfline_T **lastp; // pointer to qf_last or NULL 2031 2032 if ((qfp = (qfline_T *)alloc((unsigned)sizeof(qfline_T))) == NULL) 2033 return FAIL; 2034 if (bufnum != 0) 2035 { 2036 buf_T *buf = buflist_findnr(bufnum); 2037 2038 qfp->qf_fnum = bufnum; 2039 if (buf != NULL) 2040 buf->b_has_qf_entry |= 2041 IS_QF_LIST(qfl) ? BUF_HAS_QF_ENTRY : BUF_HAS_LL_ENTRY; 2042 } 2043 else 2044 qfp->qf_fnum = qf_get_fnum(qfl, dir, fname); 2045 if ((qfp->qf_text = vim_strsave(mesg)) == NULL) 2046 { 2047 vim_free(qfp); 2048 return FAIL; 2049 } 2050 qfp->qf_lnum = lnum; 2051 qfp->qf_col = col; 2052 qfp->qf_viscol = vis_col; 2053 if (pattern == NULL || *pattern == NUL) 2054 qfp->qf_pattern = NULL; 2055 else if ((qfp->qf_pattern = vim_strsave(pattern)) == NULL) 2056 { 2057 vim_free(qfp->qf_text); 2058 vim_free(qfp); 2059 return FAIL; 2060 } 2061 if (module == NULL || *module == NUL) 2062 qfp->qf_module = NULL; 2063 else if ((qfp->qf_module = vim_strsave(module)) == NULL) 2064 { 2065 vim_free(qfp->qf_text); 2066 vim_free(qfp->qf_pattern); 2067 vim_free(qfp); 2068 return FAIL; 2069 } 2070 qfp->qf_nr = nr; 2071 if (type != 1 && !vim_isprintc(type)) // only printable chars allowed 2072 type = 0; 2073 qfp->qf_type = type; 2074 qfp->qf_valid = valid; 2075 2076 lastp = &qfl->qf_last; 2077 if (qf_list_empty(qfl)) // first element in the list 2078 { 2079 qfl->qf_start = qfp; 2080 qfl->qf_ptr = qfp; 2081 qfl->qf_index = 0; 2082 qfp->qf_prev = NULL; 2083 } 2084 else 2085 { 2086 qfp->qf_prev = *lastp; 2087 (*lastp)->qf_next = qfp; 2088 } 2089 qfp->qf_next = NULL; 2090 qfp->qf_cleared = FALSE; 2091 *lastp = qfp; 2092 ++qfl->qf_count; 2093 if (qfl->qf_index == 0 && qfp->qf_valid) // first valid entry 2094 { 2095 qfl->qf_index = qfl->qf_count; 2096 qfl->qf_ptr = qfp; 2097 } 2098 2099 return OK; 2100 } 2101 2102 /* 2103 * Allocate a new quickfix/location list stack 2104 */ 2105 static qf_info_T * 2106 qf_alloc_stack(qfltype_T qfltype) 2107 { 2108 qf_info_T *qi; 2109 2110 qi = (qf_info_T *)alloc_clear((unsigned)sizeof(qf_info_T)); 2111 if (qi != NULL) 2112 { 2113 qi->qf_refcount++; 2114 qi->qfl_type = qfltype; 2115 qi->qf_bufnr = INVALID_QFBUFNR; 2116 } 2117 return qi; 2118 } 2119 2120 /* 2121 * Return the location list stack for window 'wp'. 2122 * If not present, allocate a location list stack 2123 */ 2124 static qf_info_T * 2125 ll_get_or_alloc_list(win_T *wp) 2126 { 2127 if (IS_LL_WINDOW(wp)) 2128 // For a location list window, use the referenced location list 2129 return wp->w_llist_ref; 2130 2131 // For a non-location list window, w_llist_ref should not point to a 2132 // location list. 2133 ll_free_all(&wp->w_llist_ref); 2134 2135 if (wp->w_llist == NULL) 2136 wp->w_llist = qf_alloc_stack(QFLT_LOCATION); // new location list 2137 return wp->w_llist; 2138 } 2139 2140 /* 2141 * Copy location list entries from 'from_qfl' to 'to_qfl'. 2142 */ 2143 static int 2144 copy_loclist_entries(qf_list_T *from_qfl, qf_list_T *to_qfl) 2145 { 2146 int i; 2147 qfline_T *from_qfp; 2148 qfline_T *prevp; 2149 2150 // copy all the location entries in this list 2151 for (i = 0, from_qfp = from_qfl->qf_start; 2152 i < from_qfl->qf_count && from_qfp != NULL; 2153 ++i, from_qfp = from_qfp->qf_next) 2154 { 2155 if (qf_add_entry(to_qfl, 2156 NULL, 2157 NULL, 2158 from_qfp->qf_module, 2159 0, 2160 from_qfp->qf_text, 2161 from_qfp->qf_lnum, 2162 from_qfp->qf_col, 2163 from_qfp->qf_viscol, 2164 from_qfp->qf_pattern, 2165 from_qfp->qf_nr, 2166 0, 2167 from_qfp->qf_valid) == FAIL) 2168 return FAIL; 2169 2170 // qf_add_entry() will not set the qf_num field, as the 2171 // directory and file names are not supplied. So the qf_fnum 2172 // field is copied here. 2173 prevp = to_qfl->qf_last; 2174 prevp->qf_fnum = from_qfp->qf_fnum; // file number 2175 prevp->qf_type = from_qfp->qf_type; // error type 2176 if (from_qfl->qf_ptr == from_qfp) 2177 to_qfl->qf_ptr = prevp; // current location 2178 } 2179 2180 return OK; 2181 } 2182 2183 /* 2184 * Copy the specified location list 'from_qfl' to 'to_qfl'. 2185 */ 2186 static int 2187 copy_loclist(qf_list_T *from_qfl, qf_list_T *to_qfl) 2188 { 2189 // Some of the fields are populated by qf_add_entry() 2190 to_qfl->qfl_type = from_qfl->qfl_type; 2191 to_qfl->qf_nonevalid = from_qfl->qf_nonevalid; 2192 to_qfl->qf_count = 0; 2193 to_qfl->qf_index = 0; 2194 to_qfl->qf_start = NULL; 2195 to_qfl->qf_last = NULL; 2196 to_qfl->qf_ptr = NULL; 2197 if (from_qfl->qf_title != NULL) 2198 to_qfl->qf_title = vim_strsave(from_qfl->qf_title); 2199 else 2200 to_qfl->qf_title = NULL; 2201 if (from_qfl->qf_ctx != NULL) 2202 { 2203 to_qfl->qf_ctx = alloc_tv(); 2204 if (to_qfl->qf_ctx != NULL) 2205 copy_tv(from_qfl->qf_ctx, to_qfl->qf_ctx); 2206 } 2207 else 2208 to_qfl->qf_ctx = NULL; 2209 2210 if (from_qfl->qf_count) 2211 if (copy_loclist_entries(from_qfl, to_qfl) == FAIL) 2212 return FAIL; 2213 2214 to_qfl->qf_index = from_qfl->qf_index; // current index in the list 2215 2216 // Assign a new ID for the location list 2217 to_qfl->qf_id = ++last_qf_id; 2218 to_qfl->qf_changedtick = 0L; 2219 2220 // When no valid entries are present in the list, qf_ptr points to 2221 // the first item in the list 2222 if (to_qfl->qf_nonevalid) 2223 { 2224 to_qfl->qf_ptr = to_qfl->qf_start; 2225 to_qfl->qf_index = 1; 2226 } 2227 2228 return OK; 2229 } 2230 2231 /* 2232 * Copy the location list stack 'from' window to 'to' window. 2233 */ 2234 void 2235 copy_loclist_stack(win_T *from, win_T *to) 2236 { 2237 qf_info_T *qi; 2238 int idx; 2239 2240 // When copying from a location list window, copy the referenced 2241 // location list. For other windows, copy the location list for 2242 // that window. 2243 if (IS_LL_WINDOW(from)) 2244 qi = from->w_llist_ref; 2245 else 2246 qi = from->w_llist; 2247 2248 if (qi == NULL) // no location list to copy 2249 return; 2250 2251 // allocate a new location list 2252 if ((to->w_llist = qf_alloc_stack(QFLT_LOCATION)) == NULL) 2253 return; 2254 2255 to->w_llist->qf_listcount = qi->qf_listcount; 2256 2257 // Copy the location lists one at a time 2258 for (idx = 0; idx < qi->qf_listcount; ++idx) 2259 { 2260 to->w_llist->qf_curlist = idx; 2261 2262 if (copy_loclist(qf_get_list(qi, idx), 2263 qf_get_list(to->w_llist, idx)) == FAIL) 2264 { 2265 qf_free_all(to); 2266 return; 2267 } 2268 } 2269 2270 to->w_llist->qf_curlist = qi->qf_curlist; // current list 2271 } 2272 2273 /* 2274 * Get buffer number for file "directory/fname". 2275 * Also sets the b_has_qf_entry flag. 2276 */ 2277 static int 2278 qf_get_fnum(qf_list_T *qfl, char_u *directory, char_u *fname) 2279 { 2280 char_u *ptr = NULL; 2281 buf_T *buf; 2282 char_u *bufname; 2283 2284 if (fname == NULL || *fname == NUL) // no file name 2285 return 0; 2286 2287 #ifdef VMS 2288 vms_remove_version(fname); 2289 #endif 2290 #ifdef BACKSLASH_IN_FILENAME 2291 if (directory != NULL) 2292 slash_adjust(directory); 2293 slash_adjust(fname); 2294 #endif 2295 if (directory != NULL && !vim_isAbsName(fname) 2296 && (ptr = concat_fnames(directory, fname, TRUE)) != NULL) 2297 { 2298 // Here we check if the file really exists. 2299 // This should normally be true, but if make works without 2300 // "leaving directory"-messages we might have missed a 2301 // directory change. 2302 if (mch_getperm(ptr) < 0) 2303 { 2304 vim_free(ptr); 2305 directory = qf_guess_filepath(qfl, fname); 2306 if (directory) 2307 ptr = concat_fnames(directory, fname, TRUE); 2308 else 2309 ptr = vim_strsave(fname); 2310 } 2311 // Use concatenated directory name and file name 2312 bufname = ptr; 2313 } 2314 else 2315 bufname = fname; 2316 2317 if (qf_last_bufname != NULL && STRCMP(bufname, qf_last_bufname) == 0 2318 && bufref_valid(&qf_last_bufref)) 2319 { 2320 buf = qf_last_bufref.br_buf; 2321 vim_free(ptr); 2322 } 2323 else 2324 { 2325 vim_free(qf_last_bufname); 2326 buf = buflist_new(bufname, NULL, (linenr_T)0, BLN_NOOPT); 2327 if (bufname == ptr) 2328 qf_last_bufname = bufname; 2329 else 2330 qf_last_bufname = vim_strsave(bufname); 2331 set_bufref(&qf_last_bufref, buf); 2332 } 2333 if (buf == NULL) 2334 return 0; 2335 2336 buf->b_has_qf_entry = 2337 IS_QF_LIST(qfl) ? BUF_HAS_QF_ENTRY : BUF_HAS_LL_ENTRY; 2338 return buf->b_fnum; 2339 } 2340 2341 /* 2342 * Push dirbuf onto the directory stack and return pointer to actual dir or 2343 * NULL on error. 2344 */ 2345 static char_u * 2346 qf_push_dir(char_u *dirbuf, struct dir_stack_T **stackptr, int is_file_stack) 2347 { 2348 struct dir_stack_T *ds_new; 2349 struct dir_stack_T *ds_ptr; 2350 2351 // allocate new stack element and hook it in 2352 ds_new = (struct dir_stack_T *)alloc((unsigned)sizeof(struct dir_stack_T)); 2353 if (ds_new == NULL) 2354 return NULL; 2355 2356 ds_new->next = *stackptr; 2357 *stackptr = ds_new; 2358 2359 // store directory on the stack 2360 if (vim_isAbsName(dirbuf) 2361 || (*stackptr)->next == NULL 2362 || (*stackptr && is_file_stack)) 2363 (*stackptr)->dirname = vim_strsave(dirbuf); 2364 else 2365 { 2366 // Okay we don't have an absolute path. 2367 // dirbuf must be a subdir of one of the directories on the stack. 2368 // Let's search... 2369 ds_new = (*stackptr)->next; 2370 (*stackptr)->dirname = NULL; 2371 while (ds_new) 2372 { 2373 vim_free((*stackptr)->dirname); 2374 (*stackptr)->dirname = concat_fnames(ds_new->dirname, dirbuf, 2375 TRUE); 2376 if (mch_isdir((*stackptr)->dirname) == TRUE) 2377 break; 2378 2379 ds_new = ds_new->next; 2380 } 2381 2382 // clean up all dirs we already left 2383 while ((*stackptr)->next != ds_new) 2384 { 2385 ds_ptr = (*stackptr)->next; 2386 (*stackptr)->next = (*stackptr)->next->next; 2387 vim_free(ds_ptr->dirname); 2388 vim_free(ds_ptr); 2389 } 2390 2391 // Nothing found -> it must be on top level 2392 if (ds_new == NULL) 2393 { 2394 vim_free((*stackptr)->dirname); 2395 (*stackptr)->dirname = vim_strsave(dirbuf); 2396 } 2397 } 2398 2399 if ((*stackptr)->dirname != NULL) 2400 return (*stackptr)->dirname; 2401 else 2402 { 2403 ds_ptr = *stackptr; 2404 *stackptr = (*stackptr)->next; 2405 vim_free(ds_ptr); 2406 return NULL; 2407 } 2408 } 2409 2410 /* 2411 * pop dirbuf from the directory stack and return previous directory or NULL if 2412 * stack is empty 2413 */ 2414 static char_u * 2415 qf_pop_dir(struct dir_stack_T **stackptr) 2416 { 2417 struct dir_stack_T *ds_ptr; 2418 2419 // TODO: Should we check if dirbuf is the directory on top of the stack? 2420 // What to do if it isn't? 2421 2422 // pop top element and free it 2423 if (*stackptr != NULL) 2424 { 2425 ds_ptr = *stackptr; 2426 *stackptr = (*stackptr)->next; 2427 vim_free(ds_ptr->dirname); 2428 vim_free(ds_ptr); 2429 } 2430 2431 // return NEW top element as current dir or NULL if stack is empty 2432 return *stackptr ? (*stackptr)->dirname : NULL; 2433 } 2434 2435 /* 2436 * clean up directory stack 2437 */ 2438 static void 2439 qf_clean_dir_stack(struct dir_stack_T **stackptr) 2440 { 2441 struct dir_stack_T *ds_ptr; 2442 2443 while ((ds_ptr = *stackptr) != NULL) 2444 { 2445 *stackptr = (*stackptr)->next; 2446 vim_free(ds_ptr->dirname); 2447 vim_free(ds_ptr); 2448 } 2449 } 2450 2451 /* 2452 * Check in which directory of the directory stack the given file can be 2453 * found. 2454 * Returns a pointer to the directory name or NULL if not found. 2455 * Cleans up intermediate directory entries. 2456 * 2457 * TODO: How to solve the following problem? 2458 * If we have this directory tree: 2459 * ./ 2460 * ./aa 2461 * ./aa/bb 2462 * ./bb 2463 * ./bb/x.c 2464 * and make says: 2465 * making all in aa 2466 * making all in bb 2467 * x.c:9: Error 2468 * Then qf_push_dir thinks we are in ./aa/bb, but we are in ./bb. 2469 * qf_guess_filepath will return NULL. 2470 */ 2471 static char_u * 2472 qf_guess_filepath(qf_list_T *qfl, char_u *filename) 2473 { 2474 struct dir_stack_T *ds_ptr; 2475 struct dir_stack_T *ds_tmp; 2476 char_u *fullname; 2477 2478 // no dirs on the stack - there's nothing we can do 2479 if (qfl->qf_dir_stack == NULL) 2480 return NULL; 2481 2482 ds_ptr = qfl->qf_dir_stack->next; 2483 fullname = NULL; 2484 while (ds_ptr) 2485 { 2486 vim_free(fullname); 2487 fullname = concat_fnames(ds_ptr->dirname, filename, TRUE); 2488 2489 // If concat_fnames failed, just go on. The worst thing that can happen 2490 // is that we delete the entire stack. 2491 if ((fullname != NULL) && (mch_getperm(fullname) >= 0)) 2492 break; 2493 2494 ds_ptr = ds_ptr->next; 2495 } 2496 2497 vim_free(fullname); 2498 2499 // clean up all dirs we already left 2500 while (qfl->qf_dir_stack->next != ds_ptr) 2501 { 2502 ds_tmp = qfl->qf_dir_stack->next; 2503 qfl->qf_dir_stack->next = qfl->qf_dir_stack->next->next; 2504 vim_free(ds_tmp->dirname); 2505 vim_free(ds_tmp); 2506 } 2507 2508 return ds_ptr == NULL ? NULL : ds_ptr->dirname; 2509 } 2510 2511 /* 2512 * Returns TRUE if a quickfix/location list with the given identifier exists. 2513 */ 2514 static int 2515 qflist_valid(win_T *wp, int_u qf_id) 2516 { 2517 qf_info_T *qi = &ql_info; 2518 int i; 2519 2520 if (wp != NULL) 2521 { 2522 qi = GET_LOC_LIST(wp); // Location list 2523 if (qi == NULL) 2524 return FALSE; 2525 } 2526 2527 for (i = 0; i < qi->qf_listcount; ++i) 2528 if (qi->qf_lists[i].qf_id == qf_id) 2529 return TRUE; 2530 2531 return FALSE; 2532 } 2533 2534 /* 2535 * When loading a file from the quickfix, the autocommands may modify it. 2536 * This may invalidate the current quickfix entry. This function checks 2537 * whether an entry is still present in the quickfix list. 2538 * Similar to location list. 2539 */ 2540 static int 2541 is_qf_entry_present(qf_list_T *qfl, qfline_T *qf_ptr) 2542 { 2543 qfline_T *qfp; 2544 int i; 2545 2546 // Search for the entry in the current list 2547 for (i = 0, qfp = qfl->qf_start; i < qfl->qf_count; 2548 ++i, qfp = qfp->qf_next) 2549 if (qfp == NULL || qfp == qf_ptr) 2550 break; 2551 2552 if (i == qfl->qf_count) // Entry is not found 2553 return FALSE; 2554 2555 return TRUE; 2556 } 2557 2558 /* 2559 * Get the next valid entry in the current quickfix/location list. The search 2560 * starts from the current entry. Returns NULL on failure. 2561 */ 2562 static qfline_T * 2563 get_next_valid_entry( 2564 qf_list_T *qfl, 2565 qfline_T *qf_ptr, 2566 int *qf_index, 2567 int dir) 2568 { 2569 int idx; 2570 int old_qf_fnum; 2571 2572 idx = *qf_index; 2573 old_qf_fnum = qf_ptr->qf_fnum; 2574 2575 do 2576 { 2577 if (idx == qfl->qf_count || qf_ptr->qf_next == NULL) 2578 return NULL; 2579 ++idx; 2580 qf_ptr = qf_ptr->qf_next; 2581 } while ((!qfl->qf_nonevalid && !qf_ptr->qf_valid) 2582 || (dir == FORWARD_FILE && qf_ptr->qf_fnum == old_qf_fnum)); 2583 2584 *qf_index = idx; 2585 return qf_ptr; 2586 } 2587 2588 /* 2589 * Get the previous valid entry in the current quickfix/location list. The 2590 * search starts from the current entry. Returns NULL on failure. 2591 */ 2592 static qfline_T * 2593 get_prev_valid_entry( 2594 qf_list_T *qfl, 2595 qfline_T *qf_ptr, 2596 int *qf_index, 2597 int dir) 2598 { 2599 int idx; 2600 int old_qf_fnum; 2601 2602 idx = *qf_index; 2603 old_qf_fnum = qf_ptr->qf_fnum; 2604 2605 do 2606 { 2607 if (idx == 1 || qf_ptr->qf_prev == NULL) 2608 return NULL; 2609 --idx; 2610 qf_ptr = qf_ptr->qf_prev; 2611 } while ((!qfl->qf_nonevalid && !qf_ptr->qf_valid) 2612 || (dir == BACKWARD_FILE && qf_ptr->qf_fnum == old_qf_fnum)); 2613 2614 *qf_index = idx; 2615 return qf_ptr; 2616 } 2617 2618 /* 2619 * Get the n'th (errornr) previous/next valid entry from the current entry in 2620 * the quickfix list. 2621 * dir == FORWARD or FORWARD_FILE: next valid entry 2622 * dir == BACKWARD or BACKWARD_FILE: previous valid entry 2623 */ 2624 static qfline_T * 2625 get_nth_valid_entry( 2626 qf_list_T *qfl, 2627 int errornr, 2628 int dir, 2629 int *new_qfidx) 2630 { 2631 qfline_T *qf_ptr = qfl->qf_ptr; 2632 int qf_idx = qfl->qf_index; 2633 qfline_T *prev_qf_ptr; 2634 int prev_index; 2635 static char_u *e_no_more_items = (char_u *)N_("E553: No more items"); 2636 char_u *err = e_no_more_items; 2637 2638 while (errornr--) 2639 { 2640 prev_qf_ptr = qf_ptr; 2641 prev_index = qf_idx; 2642 2643 if (dir == FORWARD || dir == FORWARD_FILE) 2644 qf_ptr = get_next_valid_entry(qfl, qf_ptr, &qf_idx, dir); 2645 else 2646 qf_ptr = get_prev_valid_entry(qfl, qf_ptr, &qf_idx, dir); 2647 if (qf_ptr == NULL) 2648 { 2649 qf_ptr = prev_qf_ptr; 2650 qf_idx = prev_index; 2651 if (err != NULL) 2652 { 2653 emsg(_(err)); 2654 return NULL; 2655 } 2656 break; 2657 } 2658 2659 err = NULL; 2660 } 2661 2662 *new_qfidx = qf_idx; 2663 return qf_ptr; 2664 } 2665 2666 /* 2667 * Get n'th (errornr) quickfix entry from the current entry in the quickfix 2668 * list 'qfl'. Returns a pointer to the new entry and the index in 'new_qfidx' 2669 */ 2670 static qfline_T * 2671 get_nth_entry(qf_list_T *qfl, int errornr, int *new_qfidx) 2672 { 2673 qfline_T *qf_ptr = qfl->qf_ptr; 2674 int qf_idx = qfl->qf_index; 2675 2676 // New error number is less than the current error number 2677 while (errornr < qf_idx && qf_idx > 1 && qf_ptr->qf_prev != NULL) 2678 { 2679 --qf_idx; 2680 qf_ptr = qf_ptr->qf_prev; 2681 } 2682 // New error number is greater than the current error number 2683 while (errornr > qf_idx && qf_idx < qfl->qf_count && 2684 qf_ptr->qf_next != NULL) 2685 { 2686 ++qf_idx; 2687 qf_ptr = qf_ptr->qf_next; 2688 } 2689 2690 *new_qfidx = qf_idx; 2691 return qf_ptr; 2692 } 2693 2694 /* 2695 * Get a entry specied by 'errornr' and 'dir' from the current 2696 * quickfix/location list. 'errornr' specifies the index of the entry and 'dir' 2697 * specifies the direction (FORWARD/BACKWARD/FORWARD_FILE/BACKWARD_FILE). 2698 * Returns a pointer to the entry and the index of the new entry is stored in 2699 * 'new_qfidx'. 2700 */ 2701 static qfline_T * 2702 qf_get_entry( 2703 qf_list_T *qfl, 2704 int errornr, 2705 int dir, 2706 int *new_qfidx) 2707 { 2708 qfline_T *qf_ptr = qfl->qf_ptr; 2709 int qfidx = qfl->qf_index; 2710 2711 if (dir != 0) // next/prev valid entry 2712 qf_ptr = get_nth_valid_entry(qfl, errornr, dir, &qfidx); 2713 else if (errornr != 0) // go to specified number 2714 qf_ptr = get_nth_entry(qfl, errornr, &qfidx); 2715 2716 *new_qfidx = qfidx; 2717 return qf_ptr; 2718 } 2719 2720 /* 2721 * Find a window displaying a Vim help file. 2722 */ 2723 static win_T * 2724 qf_find_help_win(void) 2725 { 2726 win_T *wp; 2727 2728 FOR_ALL_WINDOWS(wp) 2729 if (bt_help(wp->w_buffer)) 2730 return wp; 2731 2732 return NULL; 2733 } 2734 2735 /* 2736 * Set the location list for the specified window to 'qi'. 2737 */ 2738 static void 2739 win_set_loclist(win_T *wp, qf_info_T *qi) 2740 { 2741 wp->w_llist = qi; 2742 qi->qf_refcount++; 2743 } 2744 2745 /* 2746 * Find a help window or open one. If 'newwin' is TRUE, then open a new help 2747 * window. 2748 */ 2749 static int 2750 jump_to_help_window(qf_info_T *qi, int newwin, int *opened_window) 2751 { 2752 win_T *wp; 2753 int flags; 2754 2755 if (cmdmod.tab != 0 || newwin) 2756 wp = NULL; 2757 else 2758 wp = qf_find_help_win(); 2759 if (wp != NULL && wp->w_buffer->b_nwindows > 0) 2760 win_enter(wp, TRUE); 2761 else 2762 { 2763 // Split off help window; put it at far top if no position 2764 // specified, the current window is vertically split and narrow. 2765 flags = WSP_HELP; 2766 if (cmdmod.split == 0 && curwin->w_width != Columns 2767 && curwin->w_width < 80) 2768 flags |= WSP_TOP; 2769 // If the user asks to open a new window, then copy the location list. 2770 // Otherwise, don't copy the location list. 2771 if (IS_LL_STACK(qi) && !newwin) 2772 flags |= WSP_NEWLOC; 2773 2774 if (win_split(0, flags) == FAIL) 2775 return FAIL; 2776 2777 *opened_window = TRUE; 2778 2779 if (curwin->w_height < p_hh) 2780 win_setheight((int)p_hh); 2781 2782 // When using location list, the new window should use the supplied 2783 // location list. If the user asks to open a new window, then the new 2784 // window will get a copy of the location list. 2785 if (IS_LL_STACK(qi) && !newwin) 2786 win_set_loclist(curwin, qi); 2787 } 2788 2789 if (!p_im) 2790 restart_edit = 0; // don't want insert mode in help file 2791 2792 return OK; 2793 } 2794 2795 /* 2796 * Find a non-quickfix window in the current tabpage using the given location 2797 * list stack. 2798 * Returns NULL if a matching window is not found. 2799 */ 2800 static win_T * 2801 qf_find_win_with_loclist(qf_info_T *ll) 2802 { 2803 win_T *wp; 2804 2805 FOR_ALL_WINDOWS(wp) 2806 if (wp->w_llist == ll && !bt_quickfix(wp->w_buffer)) 2807 return wp; 2808 2809 return NULL; 2810 } 2811 2812 /* 2813 * Find a window containing a normal buffer 2814 */ 2815 static win_T * 2816 qf_find_win_with_normal_buf(void) 2817 { 2818 win_T *wp; 2819 2820 FOR_ALL_WINDOWS(wp) 2821 if (bt_normal(wp->w_buffer)) 2822 return wp; 2823 2824 return NULL; 2825 } 2826 2827 /* 2828 * Go to a window in any tabpage containing the specified file. Returns TRUE 2829 * if successfully jumped to the window. Otherwise returns FALSE. 2830 */ 2831 static int 2832 qf_goto_tabwin_with_file(int fnum) 2833 { 2834 tabpage_T *tp; 2835 win_T *wp; 2836 2837 FOR_ALL_TAB_WINDOWS(tp, wp) 2838 if (wp->w_buffer->b_fnum == fnum) 2839 { 2840 goto_tabpage_win(tp, wp); 2841 return TRUE; 2842 } 2843 2844 return FALSE; 2845 } 2846 2847 /* 2848 * Create a new window to show a file above the quickfix window. Called when 2849 * only the quickfix window is present. 2850 */ 2851 static int 2852 qf_open_new_file_win(qf_info_T *ll_ref) 2853 { 2854 int flags; 2855 2856 flags = WSP_ABOVE; 2857 if (ll_ref != NULL) 2858 flags |= WSP_NEWLOC; 2859 if (win_split(0, flags) == FAIL) 2860 return FAIL; // not enough room for window 2861 p_swb = empty_option; // don't split again 2862 swb_flags = 0; 2863 RESET_BINDING(curwin); 2864 if (ll_ref != NULL) 2865 // The new window should use the location list from the 2866 // location list window 2867 win_set_loclist(curwin, ll_ref); 2868 return OK; 2869 } 2870 2871 /* 2872 * Go to a window that shows the right buffer. If the window is not found, go 2873 * to the window just above the location list window. This is used for opening 2874 * a file from a location window and not from a quickfix window. If some usable 2875 * window is previously found, then it is supplied in 'use_win'. 2876 */ 2877 static void 2878 qf_goto_win_with_ll_file(win_T *use_win, int qf_fnum, qf_info_T *ll_ref) 2879 { 2880 win_T *win = use_win; 2881 2882 if (win == NULL) 2883 { 2884 // Find the window showing the selected file 2885 FOR_ALL_WINDOWS(win) 2886 if (win->w_buffer->b_fnum == qf_fnum) 2887 break; 2888 if (win == NULL) 2889 { 2890 // Find a previous usable window 2891 win = curwin; 2892 do 2893 { 2894 if (bt_normal(win->w_buffer)) 2895 break; 2896 if (win->w_prev == NULL) 2897 win = lastwin; // wrap around the top 2898 else 2899 win = win->w_prev; // go to previous window 2900 } while (win != curwin); 2901 } 2902 } 2903 win_goto(win); 2904 2905 // If the location list for the window is not set, then set it 2906 // to the location list from the location window 2907 if (win->w_llist == NULL && ll_ref != NULL) 2908 win_set_loclist(win, ll_ref); 2909 } 2910 2911 /* 2912 * Go to a window that contains the specified buffer 'qf_fnum'. If a window is 2913 * not found, then go to the window just above the quickfix window. This is 2914 * used for opening a file from a quickfix window and not from a location 2915 * window. 2916 */ 2917 static void 2918 qf_goto_win_with_qfl_file(int qf_fnum) 2919 { 2920 win_T *win; 2921 win_T *altwin; 2922 2923 win = curwin; 2924 altwin = NULL; 2925 for (;;) 2926 { 2927 if (win->w_buffer->b_fnum == qf_fnum) 2928 break; 2929 if (win->w_prev == NULL) 2930 win = lastwin; // wrap around the top 2931 else 2932 win = win->w_prev; // go to previous window 2933 2934 if (IS_QF_WINDOW(win)) 2935 { 2936 // Didn't find it, go to the window before the quickfix 2937 // window. 2938 if (altwin != NULL) 2939 win = altwin; 2940 else if (curwin->w_prev != NULL) 2941 win = curwin->w_prev; 2942 else 2943 win = curwin->w_next; 2944 break; 2945 } 2946 2947 // Remember a usable window. 2948 if (altwin == NULL && !win->w_p_pvw && bt_normal(win->w_buffer)) 2949 altwin = win; 2950 } 2951 2952 win_goto(win); 2953 } 2954 2955 /* 2956 * Find a suitable window for opening a file (qf_fnum) from the 2957 * quickfix/location list and jump to it. If the file is already opened in a 2958 * window, jump to it. Otherwise open a new window to display the file. If 2959 * 'newwin' is TRUE, then always open a new window. This is called from either 2960 * a quickfix or a location list window. 2961 */ 2962 static int 2963 qf_jump_to_usable_window(int qf_fnum, int newwin, int *opened_window) 2964 { 2965 win_T *usable_win_ptr = NULL; 2966 int usable_win; 2967 qf_info_T *ll_ref = NULL; 2968 win_T *win; 2969 2970 usable_win = 0; 2971 2972 // If opening a new window, then don't use the location list referred by 2973 // the current window. Otherwise two windows will refer to the same 2974 // location list. 2975 if (!newwin) 2976 ll_ref = curwin->w_llist_ref; 2977 2978 if (ll_ref != NULL) 2979 { 2980 // Find a non-quickfix window with this location list 2981 usable_win_ptr = qf_find_win_with_loclist(ll_ref); 2982 if (usable_win_ptr != NULL) 2983 usable_win = 1; 2984 } 2985 2986 if (!usable_win) 2987 { 2988 // Locate a window showing a normal buffer 2989 win = qf_find_win_with_normal_buf(); 2990 if (win != NULL) 2991 usable_win = 1; 2992 } 2993 2994 // If no usable window is found and 'switchbuf' contains "usetab" 2995 // then search in other tabs. 2996 if (!usable_win && (swb_flags & SWB_USETAB)) 2997 usable_win = qf_goto_tabwin_with_file(qf_fnum); 2998 2999 // If there is only one window and it is the quickfix window, create a 3000 // new one above the quickfix window. 3001 if ((ONE_WINDOW && bt_quickfix(curbuf)) || !usable_win || newwin) 3002 { 3003 if (qf_open_new_file_win(ll_ref) != OK) 3004 return FAIL; 3005 *opened_window = TRUE; // close it when fail 3006 } 3007 else 3008 { 3009 if (curwin->w_llist_ref != NULL) // In a location window 3010 qf_goto_win_with_ll_file(usable_win_ptr, qf_fnum, ll_ref); 3011 else // In a quickfix window 3012 qf_goto_win_with_qfl_file(qf_fnum); 3013 } 3014 3015 return OK; 3016 } 3017 3018 /* 3019 * Edit the selected file or help file. 3020 * Returns OK if successfully edited the file, FAIL on failing to open the 3021 * buffer and NOTDONE if the quickfix/location list was freed by an autocmd 3022 * when opening the buffer. 3023 */ 3024 static int 3025 qf_jump_edit_buffer( 3026 qf_info_T *qi, 3027 qfline_T *qf_ptr, 3028 int forceit, 3029 int prev_winid, 3030 int *opened_window) 3031 { 3032 qf_list_T *qfl = qf_get_curlist(qi); 3033 qfltype_T qfl_type = qfl->qfl_type; 3034 int retval = OK; 3035 int old_qf_curlist = qi->qf_curlist; 3036 int save_qfid = qfl->qf_id; 3037 3038 if (qf_ptr->qf_type == 1) 3039 { 3040 // Open help file (do_ecmd() will set b_help flag, readfile() will 3041 // set b_p_ro flag). 3042 if (!can_abandon(curbuf, forceit)) 3043 { 3044 no_write_message(); 3045 return FAIL; 3046 } 3047 3048 retval = do_ecmd(qf_ptr->qf_fnum, NULL, NULL, NULL, (linenr_T)1, 3049 ECMD_HIDE + ECMD_SET_HELP, 3050 prev_winid == curwin->w_id ? curwin : NULL); 3051 } 3052 else 3053 retval = buflist_getfile(qf_ptr->qf_fnum, 3054 (linenr_T)1, GETF_SETMARK | GETF_SWITCH, forceit); 3055 3056 // If a location list, check whether the associated window is still 3057 // present. 3058 if (qfl_type == QFLT_LOCATION) 3059 { 3060 win_T *wp = win_id2wp(prev_winid); 3061 if (wp == NULL && curwin->w_llist != qi) 3062 { 3063 emsg(_("E924: Current window was closed")); 3064 *opened_window = FALSE; 3065 return NOTDONE; 3066 } 3067 } 3068 3069 if (qfl_type == QFLT_QUICKFIX && !qflist_valid(NULL, save_qfid)) 3070 { 3071 emsg(_("E925: Current quickfix was changed")); 3072 return NOTDONE; 3073 } 3074 3075 if (old_qf_curlist != qi->qf_curlist 3076 || !is_qf_entry_present(qfl, qf_ptr)) 3077 { 3078 if (qfl_type == QFLT_QUICKFIX) 3079 emsg(_("E925: Current quickfix was changed")); 3080 else 3081 emsg(_(e_loc_list_changed)); 3082 return NOTDONE; 3083 } 3084 3085 return retval; 3086 } 3087 3088 /* 3089 * Go to the error line in the current file using either line/column number or 3090 * a search pattern. 3091 */ 3092 static void 3093 qf_jump_goto_line( 3094 linenr_T qf_lnum, 3095 int qf_col, 3096 char_u qf_viscol, 3097 char_u *qf_pattern) 3098 { 3099 linenr_T i; 3100 3101 if (qf_pattern == NULL) 3102 { 3103 // Go to line with error, unless qf_lnum is 0. 3104 i = qf_lnum; 3105 if (i > 0) 3106 { 3107 if (i > curbuf->b_ml.ml_line_count) 3108 i = curbuf->b_ml.ml_line_count; 3109 curwin->w_cursor.lnum = i; 3110 } 3111 if (qf_col > 0) 3112 { 3113 curwin->w_cursor.coladd = 0; 3114 if (qf_viscol == TRUE) 3115 coladvance(qf_col - 1); 3116 else 3117 curwin->w_cursor.col = qf_col - 1; 3118 curwin->w_set_curswant = TRUE; 3119 check_cursor(); 3120 } 3121 else 3122 beginline(BL_WHITE | BL_FIX); 3123 } 3124 else 3125 { 3126 pos_T save_cursor; 3127 3128 // Move the cursor to the first line in the buffer 3129 save_cursor = curwin->w_cursor; 3130 curwin->w_cursor.lnum = 0; 3131 if (!do_search(NULL, '/', qf_pattern, (long)1, 3132 SEARCH_KEEP, NULL, NULL)) 3133 curwin->w_cursor = save_cursor; 3134 } 3135 } 3136 3137 /* 3138 * Display quickfix list index and size message 3139 */ 3140 static void 3141 qf_jump_print_msg( 3142 qf_info_T *qi, 3143 int qf_index, 3144 qfline_T *qf_ptr, 3145 buf_T *old_curbuf, 3146 linenr_T old_lnum) 3147 { 3148 linenr_T i; 3149 int len; 3150 3151 // Update the screen before showing the message, unless the screen 3152 // scrolled up. 3153 if (!msg_scrolled) 3154 update_topline_redraw(); 3155 sprintf((char *)IObuff, _("(%d of %d)%s%s: "), qf_index, 3156 qf_get_curlist(qi)->qf_count, 3157 qf_ptr->qf_cleared ? _(" (line deleted)") : "", 3158 (char *)qf_types(qf_ptr->qf_type, qf_ptr->qf_nr)); 3159 // Add the message, skipping leading whitespace and newlines. 3160 len = (int)STRLEN(IObuff); 3161 qf_fmt_text(skipwhite(qf_ptr->qf_text), IObuff + len, IOSIZE - len); 3162 3163 // Output the message. Overwrite to avoid scrolling when the 'O' 3164 // flag is present in 'shortmess'; But when not jumping, print the 3165 // whole message. 3166 i = msg_scroll; 3167 if (curbuf == old_curbuf && curwin->w_cursor.lnum == old_lnum) 3168 msg_scroll = TRUE; 3169 else if (!msg_scrolled && shortmess(SHM_OVERALL)) 3170 msg_scroll = FALSE; 3171 msg_attr_keep((char *)IObuff, 0, TRUE); 3172 msg_scroll = i; 3173 } 3174 3175 /* 3176 * Find a usable window for opening a file from the quickfix/location list. If 3177 * a window is not found then open a new window. If 'newwin' is TRUE, then open 3178 * a new window. 3179 * Returns OK if successfully jumped or opened a window. Returns FAIL if not 3180 * able to jump/open a window. Returns NOTDONE if a file is not associated 3181 * with the entry. 3182 */ 3183 static int 3184 qf_jump_open_window( 3185 qf_info_T *qi, 3186 qfline_T *qf_ptr, 3187 int newwin, 3188 int *opened_window) 3189 { 3190 // For ":helpgrep" find a help window or open one. 3191 if (qf_ptr->qf_type == 1 && (!bt_help(curwin->w_buffer) || cmdmod.tab != 0)) 3192 if (jump_to_help_window(qi, newwin, opened_window) == FAIL) 3193 return FAIL; 3194 3195 // If currently in the quickfix window, find another window to show the 3196 // file in. 3197 if (bt_quickfix(curbuf) && !*opened_window) 3198 { 3199 // If there is no file specified, we don't know where to go. 3200 // But do advance, otherwise ":cn" gets stuck. 3201 if (qf_ptr->qf_fnum == 0) 3202 return NOTDONE; 3203 3204 if (qf_jump_to_usable_window(qf_ptr->qf_fnum, newwin, 3205 opened_window) == FAIL) 3206 return FAIL; 3207 } 3208 3209 return OK; 3210 } 3211 3212 /* 3213 * Edit a selected file from the quickfix/location list and jump to a 3214 * particular line/column, adjust the folds and display a message about the 3215 * jump. 3216 * Returns OK on success and FAIL on failing to open the file/buffer. Returns 3217 * NOTDONE if the quickfix/location list is freed by an autocmd when opening 3218 * the file. 3219 */ 3220 static int 3221 qf_jump_to_buffer( 3222 qf_info_T *qi, 3223 int qf_index, 3224 qfline_T *qf_ptr, 3225 int forceit, 3226 int prev_winid, 3227 int *opened_window, 3228 int openfold, 3229 int print_message) 3230 { 3231 buf_T *old_curbuf; 3232 linenr_T old_lnum; 3233 int retval = OK; 3234 3235 // If there is a file name, read the wanted file if needed, and check 3236 // autowrite etc. 3237 old_curbuf = curbuf; 3238 old_lnum = curwin->w_cursor.lnum; 3239 3240 if (qf_ptr->qf_fnum != 0) 3241 { 3242 retval = qf_jump_edit_buffer(qi, qf_ptr, forceit, prev_winid, 3243 opened_window); 3244 if (retval != OK) 3245 return retval; 3246 } 3247 3248 // When not switched to another buffer, still need to set pc mark 3249 if (curbuf == old_curbuf) 3250 setpcmark(); 3251 3252 qf_jump_goto_line(qf_ptr->qf_lnum, qf_ptr->qf_col, qf_ptr->qf_viscol, 3253 qf_ptr->qf_pattern); 3254 3255 #ifdef FEAT_FOLDING 3256 if ((fdo_flags & FDO_QUICKFIX) && openfold) 3257 foldOpenCursor(); 3258 #endif 3259 if (print_message) 3260 qf_jump_print_msg(qi, qf_index, qf_ptr, old_curbuf, old_lnum); 3261 3262 return retval; 3263 } 3264 3265 /* 3266 * Jump to a quickfix line and try to use an existing window. 3267 */ 3268 void 3269 qf_jump(qf_info_T *qi, 3270 int dir, 3271 int errornr, 3272 int forceit) 3273 { 3274 qf_jump_newwin(qi, dir, errornr, forceit, FALSE); 3275 } 3276 3277 /* 3278 * Jump to a quickfix line. 3279 * If dir == 0 go to entry "errornr". 3280 * If dir == FORWARD go "errornr" valid entries forward. 3281 * If dir == BACKWARD go "errornr" valid entries backward. 3282 * If dir == FORWARD_FILE go "errornr" valid entries files backward. 3283 * If dir == BACKWARD_FILE go "errornr" valid entries files backward 3284 * else if "errornr" is zero, redisplay the same line 3285 * If 'forceit' is TRUE, then can discard changes to the current buffer. 3286 * If 'newwin' is TRUE, then open the file in a new window. 3287 */ 3288 void 3289 qf_jump_newwin(qf_info_T *qi, 3290 int dir, 3291 int errornr, 3292 int forceit, 3293 int newwin) 3294 { 3295 qf_list_T *qfl; 3296 qfline_T *qf_ptr; 3297 qfline_T *old_qf_ptr; 3298 int qf_index; 3299 int old_qf_index; 3300 char_u *old_swb = p_swb; 3301 unsigned old_swb_flags = swb_flags; 3302 int prev_winid; 3303 int opened_window = FALSE; 3304 int print_message = TRUE; 3305 #ifdef FEAT_FOLDING 3306 int old_KeyTyped = KeyTyped; // getting file may reset it 3307 #endif 3308 int retval = OK; 3309 3310 if (qi == NULL) 3311 qi = &ql_info; 3312 3313 if (qf_stack_empty(qi) || qf_list_empty(qf_get_curlist(qi))) 3314 { 3315 emsg(_(e_quickfix)); 3316 return; 3317 } 3318 3319 incr_quickfix_busy(); 3320 3321 qfl = qf_get_curlist(qi); 3322 3323 qf_ptr = qfl->qf_ptr; 3324 old_qf_ptr = qf_ptr; 3325 qf_index = qfl->qf_index; 3326 old_qf_index = qf_index; 3327 3328 qf_ptr = qf_get_entry(qfl, errornr, dir, &qf_index); 3329 if (qf_ptr == NULL) 3330 { 3331 qf_ptr = old_qf_ptr; 3332 qf_index = old_qf_index; 3333 goto theend; 3334 } 3335 3336 qfl->qf_index = qf_index; 3337 if (qf_win_pos_update(qi, old_qf_index)) 3338 // No need to print the error message if it's visible in the error 3339 // window 3340 print_message = FALSE; 3341 3342 prev_winid = curwin->w_id; 3343 3344 retval = qf_jump_open_window(qi, qf_ptr, newwin, &opened_window); 3345 if (retval == FAIL) 3346 goto failed; 3347 if (retval == NOTDONE) 3348 goto theend; 3349 3350 retval = qf_jump_to_buffer(qi, qf_index, qf_ptr, forceit, prev_winid, 3351 &opened_window, old_KeyTyped, print_message); 3352 if (retval == NOTDONE) 3353 { 3354 // Quickfix/location list is freed by an autocmd 3355 qi = NULL; 3356 qf_ptr = NULL; 3357 } 3358 3359 if (retval != OK) 3360 { 3361 if (opened_window) 3362 win_close(curwin, TRUE); // Close opened window 3363 if (qf_ptr != NULL && qf_ptr->qf_fnum != 0) 3364 { 3365 // Couldn't open file, so put index back where it was. This could 3366 // happen if the file was readonly and we changed something. 3367 failed: 3368 qf_ptr = old_qf_ptr; 3369 qf_index = old_qf_index; 3370 } 3371 } 3372 theend: 3373 if (qi != NULL) 3374 { 3375 qfl->qf_ptr = qf_ptr; 3376 qfl->qf_index = qf_index; 3377 } 3378 if (p_swb != old_swb) 3379 { 3380 // Restore old 'switchbuf' value, but not when an autocommand or 3381 // modeline has changed the value. 3382 if (p_swb == empty_option) 3383 { 3384 p_swb = old_swb; 3385 swb_flags = old_swb_flags; 3386 } 3387 else 3388 free_string_option(old_swb); 3389 } 3390 decr_quickfix_busy(); 3391 } 3392 3393 // Highlight attributes used for displaying entries from the quickfix list. 3394 static int qfFileAttr; 3395 static int qfSepAttr; 3396 static int qfLineAttr; 3397 3398 /* 3399 * Display information about a single entry from the quickfix/location list. 3400 * Used by ":clist/:llist" commands. 3401 * 'cursel' will be set to TRUE for the currently selected entry in the 3402 * quickfix list. 3403 */ 3404 static void 3405 qf_list_entry(qfline_T *qfp, int qf_idx, int cursel) 3406 { 3407 char_u *fname; 3408 buf_T *buf; 3409 int filter_entry; 3410 3411 fname = NULL; 3412 if (qfp->qf_module != NULL && *qfp->qf_module != NUL) 3413 vim_snprintf((char *)IObuff, IOSIZE, "%2d %s", qf_idx, 3414 (char *)qfp->qf_module); 3415 else { 3416 if (qfp->qf_fnum != 0 3417 && (buf = buflist_findnr(qfp->qf_fnum)) != NULL) 3418 { 3419 fname = buf->b_fname; 3420 if (qfp->qf_type == 1) // :helpgrep 3421 fname = gettail(fname); 3422 } 3423 if (fname == NULL) 3424 sprintf((char *)IObuff, "%2d", qf_idx); 3425 else 3426 vim_snprintf((char *)IObuff, IOSIZE, "%2d %s", 3427 qf_idx, (char *)fname); 3428 } 3429 3430 // Support for filtering entries using :filter /pat/ clist 3431 // Match against the module name, file name, search pattern and 3432 // text of the entry. 3433 filter_entry = TRUE; 3434 if (qfp->qf_module != NULL && *qfp->qf_module != NUL) 3435 filter_entry &= message_filtered(qfp->qf_module); 3436 if (filter_entry && fname != NULL) 3437 filter_entry &= message_filtered(fname); 3438 if (filter_entry && qfp->qf_pattern != NULL) 3439 filter_entry &= message_filtered(qfp->qf_pattern); 3440 if (filter_entry) 3441 filter_entry &= message_filtered(qfp->qf_text); 3442 if (filter_entry) 3443 return; 3444 3445 msg_putchar('\n'); 3446 msg_outtrans_attr(IObuff, cursel ? HL_ATTR(HLF_QFL) : qfFileAttr); 3447 3448 if (qfp->qf_lnum != 0) 3449 msg_puts_attr(":", qfSepAttr); 3450 if (qfp->qf_lnum == 0) 3451 IObuff[0] = NUL; 3452 else if (qfp->qf_col == 0) 3453 sprintf((char *)IObuff, "%ld", qfp->qf_lnum); 3454 else 3455 sprintf((char *)IObuff, "%ld col %d", 3456 qfp->qf_lnum, qfp->qf_col); 3457 sprintf((char *)IObuff + STRLEN(IObuff), "%s", 3458 (char *)qf_types(qfp->qf_type, qfp->qf_nr)); 3459 msg_puts_attr((char *)IObuff, qfLineAttr); 3460 msg_puts_attr(":", qfSepAttr); 3461 if (qfp->qf_pattern != NULL) 3462 { 3463 qf_fmt_text(qfp->qf_pattern, IObuff, IOSIZE); 3464 msg_puts((char *)IObuff); 3465 msg_puts_attr(":", qfSepAttr); 3466 } 3467 msg_puts(" "); 3468 3469 // Remove newlines and leading whitespace from the text. For an 3470 // unrecognized line keep the indent, the compiler may mark a word 3471 // with ^^^^. 3472 qf_fmt_text((fname != NULL || qfp->qf_lnum != 0) 3473 ? skipwhite(qfp->qf_text) : qfp->qf_text, 3474 IObuff, IOSIZE); 3475 msg_prt_line(IObuff, FALSE); 3476 out_flush(); // show one line at a time 3477 } 3478 3479 /* 3480 * ":clist": list all errors 3481 * ":llist": list all locations 3482 */ 3483 void 3484 qf_list(exarg_T *eap) 3485 { 3486 qf_list_T *qfl; 3487 qfline_T *qfp; 3488 int i; 3489 int idx1 = 1; 3490 int idx2 = -1; 3491 char_u *arg = eap->arg; 3492 int plus = FALSE; 3493 int all = eap->forceit; // if not :cl!, only show 3494 // recognised errors 3495 qf_info_T *qi = &ql_info; 3496 3497 if (is_loclist_cmd(eap->cmdidx)) 3498 { 3499 qi = GET_LOC_LIST(curwin); 3500 if (qi == NULL) 3501 { 3502 emsg(_(e_loclist)); 3503 return; 3504 } 3505 } 3506 3507 if (qf_stack_empty(qi) || qf_list_empty(qf_get_curlist(qi))) 3508 { 3509 emsg(_(e_quickfix)); 3510 return; 3511 } 3512 if (*arg == '+') 3513 { 3514 ++arg; 3515 plus = TRUE; 3516 } 3517 if (!get_list_range(&arg, &idx1, &idx2) || *arg != NUL) 3518 { 3519 emsg(_(e_trailing)); 3520 return; 3521 } 3522 qfl = qf_get_curlist(qi); 3523 if (plus) 3524 { 3525 i = qfl->qf_index; 3526 idx2 = i + idx1; 3527 idx1 = i; 3528 } 3529 else 3530 { 3531 i = qfl->qf_count; 3532 if (idx1 < 0) 3533 idx1 = (-idx1 > i) ? 0 : idx1 + i + 1; 3534 if (idx2 < 0) 3535 idx2 = (-idx2 > i) ? 0 : idx2 + i + 1; 3536 } 3537 3538 // Shorten all the file names, so that it is easy to read 3539 shorten_fnames(FALSE); 3540 3541 // Get the attributes for the different quickfix highlight items. Note 3542 // that this depends on syntax items defined in the qf.vim syntax file 3543 qfFileAttr = syn_name2attr((char_u *)"qfFileName"); 3544 if (qfFileAttr == 0) 3545 qfFileAttr = HL_ATTR(HLF_D); 3546 qfSepAttr = syn_name2attr((char_u *)"qfSeparator"); 3547 if (qfSepAttr == 0) 3548 qfSepAttr = HL_ATTR(HLF_D); 3549 qfLineAttr = syn_name2attr((char_u *)"qfLineNr"); 3550 if (qfLineAttr == 0) 3551 qfLineAttr = HL_ATTR(HLF_N); 3552 3553 if (qfl->qf_nonevalid) 3554 all = TRUE; 3555 qfp = qfl->qf_start; 3556 for (i = 1; !got_int && i <= qfl->qf_count; ) 3557 { 3558 if ((qfp->qf_valid || all) && idx1 <= i && i <= idx2) 3559 { 3560 if (got_int) 3561 break; 3562 3563 qf_list_entry(qfp, i, i == qfl->qf_index); 3564 } 3565 3566 qfp = qfp->qf_next; 3567 if (qfp == NULL) 3568 break; 3569 ++i; 3570 ui_breakcheck(); 3571 } 3572 } 3573 3574 /* 3575 * Remove newlines and leading whitespace from an error message. 3576 * Put the result in "buf[bufsize]". 3577 */ 3578 static void 3579 qf_fmt_text(char_u *text, char_u *buf, int bufsize) 3580 { 3581 int i; 3582 char_u *p = text; 3583 3584 for (i = 0; *p != NUL && i < bufsize - 1; ++i) 3585 { 3586 if (*p == '\n') 3587 { 3588 buf[i] = ' '; 3589 while (*++p != NUL) 3590 if (!VIM_ISWHITE(*p) && *p != '\n') 3591 break; 3592 } 3593 else 3594 buf[i] = *p++; 3595 } 3596 buf[i] = NUL; 3597 } 3598 3599 /* 3600 * Display information (list number, list size and the title) about a 3601 * quickfix/location list. 3602 */ 3603 static void 3604 qf_msg(qf_info_T *qi, int which, char *lead) 3605 { 3606 char *title = (char *)qi->qf_lists[which].qf_title; 3607 int count = qi->qf_lists[which].qf_count; 3608 char_u buf[IOSIZE]; 3609 3610 vim_snprintf((char *)buf, IOSIZE, _("%serror list %d of %d; %d errors "), 3611 lead, 3612 which + 1, 3613 qi->qf_listcount, 3614 count); 3615 3616 if (title != NULL) 3617 { 3618 size_t len = STRLEN(buf); 3619 3620 if (len < 34) 3621 { 3622 vim_memset(buf + len, ' ', 34 - len); 3623 buf[34] = NUL; 3624 } 3625 vim_strcat(buf, (char_u *)title, IOSIZE); 3626 } 3627 trunc_string(buf, buf, Columns - 1, IOSIZE); 3628 msg((char *)buf); 3629 } 3630 3631 /* 3632 * ":colder [count]": Up in the quickfix stack. 3633 * ":cnewer [count]": Down in the quickfix stack. 3634 * ":lolder [count]": Up in the location list stack. 3635 * ":lnewer [count]": Down in the location list stack. 3636 */ 3637 void 3638 qf_age(exarg_T *eap) 3639 { 3640 qf_info_T *qi = &ql_info; 3641 int count; 3642 3643 if (is_loclist_cmd(eap->cmdidx)) 3644 { 3645 qi = GET_LOC_LIST(curwin); 3646 if (qi == NULL) 3647 { 3648 emsg(_(e_loclist)); 3649 return; 3650 } 3651 } 3652 3653 if (eap->addr_count != 0) 3654 count = eap->line2; 3655 else 3656 count = 1; 3657 while (count--) 3658 { 3659 if (eap->cmdidx == CMD_colder || eap->cmdidx == CMD_lolder) 3660 { 3661 if (qi->qf_curlist == 0) 3662 { 3663 emsg(_("E380: At bottom of quickfix stack")); 3664 break; 3665 } 3666 --qi->qf_curlist; 3667 } 3668 else 3669 { 3670 if (qi->qf_curlist >= qi->qf_listcount - 1) 3671 { 3672 emsg(_("E381: At top of quickfix stack")); 3673 break; 3674 } 3675 ++qi->qf_curlist; 3676 } 3677 } 3678 qf_msg(qi, qi->qf_curlist, ""); 3679 qf_update_buffer(qi, NULL); 3680 } 3681 3682 /* 3683 * Display the information about all the quickfix/location lists in the stack 3684 */ 3685 void 3686 qf_history(exarg_T *eap) 3687 { 3688 qf_info_T *qi = &ql_info; 3689 int i; 3690 3691 if (is_loclist_cmd(eap->cmdidx)) 3692 qi = GET_LOC_LIST(curwin); 3693 if (qf_stack_empty(qi)) 3694 msg(_("No entries")); 3695 else 3696 for (i = 0; i < qi->qf_listcount; ++i) 3697 qf_msg(qi, i, i == qi->qf_curlist ? "> " : " "); 3698 } 3699 3700 /* 3701 * Free all the entries in the error list "idx". Note that other information 3702 * associated with the list like context and title are not freed. 3703 */ 3704 static void 3705 qf_free_items(qf_list_T *qfl) 3706 { 3707 qfline_T *qfp; 3708 qfline_T *qfpnext; 3709 int stop = FALSE; 3710 3711 while (qfl->qf_count && qfl->qf_start != NULL) 3712 { 3713 qfp = qfl->qf_start; 3714 qfpnext = qfp->qf_next; 3715 if (!stop) 3716 { 3717 vim_free(qfp->qf_module); 3718 vim_free(qfp->qf_text); 3719 vim_free(qfp->qf_pattern); 3720 stop = (qfp == qfpnext); 3721 vim_free(qfp); 3722 if (stop) 3723 // Somehow qf_count may have an incorrect value, set it to 1 3724 // to avoid crashing when it's wrong. 3725 // TODO: Avoid qf_count being incorrect. 3726 qfl->qf_count = 1; 3727 } 3728 qfl->qf_start = qfpnext; 3729 --qfl->qf_count; 3730 } 3731 3732 qfl->qf_index = 0; 3733 qfl->qf_start = NULL; 3734 qfl->qf_last = NULL; 3735 qfl->qf_ptr = NULL; 3736 qfl->qf_nonevalid = TRUE; 3737 3738 qf_clean_dir_stack(&qfl->qf_dir_stack); 3739 qfl->qf_directory = NULL; 3740 qf_clean_dir_stack(&qfl->qf_file_stack); 3741 qfl->qf_currfile = NULL; 3742 qfl->qf_multiline = FALSE; 3743 qfl->qf_multiignore = FALSE; 3744 qfl->qf_multiscan = FALSE; 3745 } 3746 3747 /* 3748 * Free error list "idx". Frees all the entries in the quickfix list, 3749 * associated context information and the title. 3750 */ 3751 static void 3752 qf_free(qf_list_T *qfl) 3753 { 3754 qf_free_items(qfl); 3755 3756 VIM_CLEAR(qfl->qf_title); 3757 free_tv(qfl->qf_ctx); 3758 qfl->qf_ctx = NULL; 3759 qfl->qf_id = 0; 3760 qfl->qf_changedtick = 0L; 3761 } 3762 3763 /* 3764 * qf_mark_adjust: adjust marks 3765 */ 3766 void 3767 qf_mark_adjust( 3768 win_T *wp, 3769 linenr_T line1, 3770 linenr_T line2, 3771 long amount, 3772 long amount_after) 3773 { 3774 int i; 3775 qfline_T *qfp; 3776 int idx; 3777 qf_info_T *qi = &ql_info; 3778 int found_one = FALSE; 3779 int buf_has_flag = wp == NULL ? BUF_HAS_QF_ENTRY : BUF_HAS_LL_ENTRY; 3780 3781 if (!(curbuf->b_has_qf_entry & buf_has_flag)) 3782 return; 3783 if (wp != NULL) 3784 { 3785 if (wp->w_llist == NULL) 3786 return; 3787 qi = wp->w_llist; 3788 } 3789 3790 for (idx = 0; idx < qi->qf_listcount; ++idx) 3791 { 3792 qf_list_T *qfl = qf_get_list(qi, idx); 3793 3794 if (!qf_list_empty(qfl)) 3795 for (i = 0, qfp = qfl->qf_start; 3796 i < qfl->qf_count && qfp != NULL; 3797 ++i, qfp = qfp->qf_next) 3798 if (qfp->qf_fnum == curbuf->b_fnum) 3799 { 3800 found_one = TRUE; 3801 if (qfp->qf_lnum >= line1 && qfp->qf_lnum <= line2) 3802 { 3803 if (amount == MAXLNUM) 3804 qfp->qf_cleared = TRUE; 3805 else 3806 qfp->qf_lnum += amount; 3807 } 3808 else if (amount_after && qfp->qf_lnum > line2) 3809 qfp->qf_lnum += amount_after; 3810 } 3811 } 3812 3813 if (!found_one) 3814 curbuf->b_has_qf_entry &= ~buf_has_flag; 3815 } 3816 3817 /* 3818 * Make a nice message out of the error character and the error number: 3819 * char number message 3820 * e or E 0 " error" 3821 * w or W 0 " warning" 3822 * i or I 0 " info" 3823 * 0 0 "" 3824 * other 0 " c" 3825 * e or E n " error n" 3826 * w or W n " warning n" 3827 * i or I n " info n" 3828 * 0 n " error n" 3829 * other n " c n" 3830 * 1 x "" :helpgrep 3831 */ 3832 static char_u * 3833 qf_types(int c, int nr) 3834 { 3835 static char_u buf[20]; 3836 static char_u cc[3]; 3837 char_u *p; 3838 3839 if (c == 'W' || c == 'w') 3840 p = (char_u *)" warning"; 3841 else if (c == 'I' || c == 'i') 3842 p = (char_u *)" info"; 3843 else if (c == 'E' || c == 'e' || (c == 0 && nr > 0)) 3844 p = (char_u *)" error"; 3845 else if (c == 0 || c == 1) 3846 p = (char_u *)""; 3847 else 3848 { 3849 cc[0] = ' '; 3850 cc[1] = c; 3851 cc[2] = NUL; 3852 p = cc; 3853 } 3854 3855 if (nr <= 0) 3856 return p; 3857 3858 sprintf((char *)buf, "%s %3d", (char *)p, nr); 3859 return buf; 3860 } 3861 3862 /* 3863 * When "split" is FALSE: Open the entry/result under the cursor. 3864 * When "split" is TRUE: Open the entry/result under the cursor in a new window. 3865 */ 3866 void 3867 qf_view_result(int split) 3868 { 3869 qf_info_T *qi = &ql_info; 3870 3871 if (!bt_quickfix(curbuf)) 3872 return; 3873 3874 if (IS_LL_WINDOW(curwin)) 3875 qi = GET_LOC_LIST(curwin); 3876 3877 if (qf_list_empty(qf_get_curlist(qi))) 3878 { 3879 emsg(_(e_quickfix)); 3880 return; 3881 } 3882 3883 if (split) 3884 { 3885 // Open the selected entry in a new window 3886 qf_jump_newwin(qi, 0, (long)curwin->w_cursor.lnum, FALSE, TRUE); 3887 do_cmdline_cmd((char_u *) "clearjumps"); 3888 return; 3889 } 3890 3891 do_cmdline_cmd((char_u *)(IS_LL_WINDOW(curwin) ? ".ll" : ".cc")); 3892 } 3893 3894 /* 3895 * ":cwindow": open the quickfix window if we have errors to display, 3896 * close it if not. 3897 * ":lwindow": open the location list window if we have locations to display, 3898 * close it if not. 3899 */ 3900 void 3901 ex_cwindow(exarg_T *eap) 3902 { 3903 qf_info_T *qi = &ql_info; 3904 qf_list_T *qfl; 3905 win_T *win; 3906 3907 if (is_loclist_cmd(eap->cmdidx)) 3908 { 3909 qi = GET_LOC_LIST(curwin); 3910 if (qi == NULL) 3911 return; 3912 } 3913 3914 qfl = qf_get_curlist(qi); 3915 3916 // Look for an existing quickfix window. 3917 win = qf_find_win(qi); 3918 3919 // If a quickfix window is open but we have no errors to display, 3920 // close the window. If a quickfix window is not open, then open 3921 // it if we have errors; otherwise, leave it closed. 3922 if (qf_stack_empty(qi) 3923 || qfl->qf_nonevalid 3924 || qf_list_empty(qfl)) 3925 { 3926 if (win != NULL) 3927 ex_cclose(eap); 3928 } 3929 else if (win == NULL) 3930 ex_copen(eap); 3931 } 3932 3933 /* 3934 * ":cclose": close the window showing the list of errors. 3935 * ":lclose": close the window showing the location list 3936 */ 3937 void 3938 ex_cclose(exarg_T *eap) 3939 { 3940 win_T *win = NULL; 3941 qf_info_T *qi = &ql_info; 3942 3943 if (is_loclist_cmd(eap->cmdidx)) 3944 { 3945 qi = GET_LOC_LIST(curwin); 3946 if (qi == NULL) 3947 return; 3948 } 3949 3950 // Find existing quickfix window and close it. 3951 win = qf_find_win(qi); 3952 if (win != NULL) 3953 win_close(win, FALSE); 3954 } 3955 3956 /* 3957 * Set "w:quickfix_title" if "qi" has a title. 3958 */ 3959 static void 3960 qf_set_title_var(qf_list_T *qfl) 3961 { 3962 if (qfl->qf_title != NULL) 3963 set_internal_string_var((char_u *)"w:quickfix_title", qfl->qf_title); 3964 } 3965 3966 /* 3967 * Goto a quickfix or location list window (if present). 3968 * Returns OK if the window is found, FAIL otherwise. 3969 */ 3970 static int 3971 qf_goto_cwindow(qf_info_T *qi, int resize, int sz, int vertsplit) 3972 { 3973 win_T *win; 3974 3975 win = qf_find_win(qi); 3976 if (win == NULL) 3977 return FAIL; 3978 3979 win_goto(win); 3980 if (resize) 3981 { 3982 if (vertsplit) 3983 { 3984 if (sz != win->w_width) 3985 win_setwidth(sz); 3986 } 3987 else if (sz != win->w_height) 3988 win_setheight(sz); 3989 } 3990 3991 return OK; 3992 } 3993 3994 /* 3995 * Set options for the buffer in the quickfix or location list window. 3996 */ 3997 static void 3998 qf_set_cwindow_options(void) 3999 { 4000 // switch off 'swapfile' 4001 set_option_value((char_u *)"swf", 0L, NULL, OPT_LOCAL); 4002 set_option_value((char_u *)"bt", 0L, (char_u *)"quickfix", 4003 OPT_LOCAL); 4004 set_option_value((char_u *)"bh", 0L, (char_u *)"hide", OPT_LOCAL); 4005 RESET_BINDING(curwin); 4006 #ifdef FEAT_DIFF 4007 curwin->w_p_diff = FALSE; 4008 #endif 4009 #ifdef FEAT_FOLDING 4010 set_option_value((char_u *)"fdm", 0L, (char_u *)"manual", 4011 OPT_LOCAL); 4012 #endif 4013 } 4014 4015 /* 4016 * Open a new quickfix or location list window, load the quickfix buffer and 4017 * set the appropriate options for the window. 4018 * Returns FAIL if the window could not be opened. 4019 */ 4020 static int 4021 qf_open_new_cwindow(qf_info_T *qi, int height) 4022 { 4023 buf_T *qf_buf; 4024 win_T *oldwin = curwin; 4025 tabpage_T *prevtab = curtab; 4026 int flags = 0; 4027 win_T *win; 4028 4029 qf_buf = qf_find_buf(qi); 4030 4031 // The current window becomes the previous window afterwards. 4032 win = curwin; 4033 4034 if (IS_QF_STACK(qi) && cmdmod.split == 0) 4035 // Create the new quickfix window at the very bottom, except when 4036 // :belowright or :aboveleft is used. 4037 win_goto(lastwin); 4038 // Default is to open the window below the current window 4039 if (cmdmod.split == 0) 4040 flags = WSP_BELOW; 4041 flags |= WSP_NEWLOC; 4042 if (win_split(height, flags) == FAIL) 4043 return FAIL; // not enough room for window 4044 RESET_BINDING(curwin); 4045 4046 if (IS_LL_STACK(qi)) 4047 { 4048 // For the location list window, create a reference to the 4049 // location list stack from the window 'win'. 4050 curwin->w_llist_ref = qi; 4051 qi->qf_refcount++; 4052 } 4053 4054 if (oldwin != curwin) 4055 oldwin = NULL; // don't store info when in another window 4056 if (qf_buf != NULL) 4057 { 4058 // Use the existing quickfix buffer 4059 (void)do_ecmd(qf_buf->b_fnum, NULL, NULL, NULL, ECMD_ONE, 4060 ECMD_HIDE + ECMD_OLDBUF, oldwin); 4061 } 4062 else 4063 { 4064 // Create a new quickfix buffer 4065 (void)do_ecmd(0, NULL, NULL, NULL, ECMD_ONE, ECMD_HIDE, oldwin); 4066 4067 // save the number of the new buffer 4068 qi->qf_bufnr = curbuf->b_fnum; 4069 } 4070 4071 // Set the options for the quickfix buffer/window (if not already done) 4072 // Do this even if the quickfix buffer was already present, as an autocmd 4073 // might have previously deleted (:bdelete) the quickfix buffer. 4074 if (curbuf->b_p_bt[0] != 'q') 4075 qf_set_cwindow_options(); 4076 4077 // Only set the height when still in the same tab page and there is no 4078 // window to the side. 4079 if (curtab == prevtab && curwin->w_width == Columns) 4080 win_setheight(height); 4081 curwin->w_p_wfh = TRUE; // set 'winfixheight' 4082 if (win_valid(win)) 4083 prevwin = win; 4084 4085 return OK; 4086 } 4087 4088 /* 4089 * ":copen": open a window that shows the list of errors. 4090 * ":lopen": open a window that shows the location list. 4091 */ 4092 void 4093 ex_copen(exarg_T *eap) 4094 { 4095 qf_info_T *qi = &ql_info; 4096 qf_list_T *qfl; 4097 int height; 4098 int status = FAIL; 4099 int lnum; 4100 4101 if (is_loclist_cmd(eap->cmdidx)) 4102 { 4103 qi = GET_LOC_LIST(curwin); 4104 if (qi == NULL) 4105 { 4106 emsg(_(e_loclist)); 4107 return; 4108 } 4109 } 4110 4111 incr_quickfix_busy(); 4112 4113 if (eap->addr_count != 0) 4114 height = eap->line2; 4115 else 4116 height = QF_WINHEIGHT; 4117 4118 reset_VIsual_and_resel(); // stop Visual mode 4119 #ifdef FEAT_GUI 4120 need_mouse_correct = TRUE; 4121 #endif 4122 4123 // Find an existing quickfix window, or open a new one. 4124 if (cmdmod.tab == 0) 4125 status = qf_goto_cwindow(qi, eap->addr_count != 0, height, 4126 cmdmod.split & WSP_VERT); 4127 if (status == FAIL) 4128 if (qf_open_new_cwindow(qi, height) == FAIL) 4129 { 4130 decr_quickfix_busy(); 4131 return; 4132 } 4133 4134 qfl = qf_get_curlist(qi); 4135 qf_set_title_var(qfl); 4136 // Save the current index here, as updating the quickfix buffer may free 4137 // the quickfix list 4138 lnum = qfl->qf_index; 4139 4140 // Fill the buffer with the quickfix list. 4141 qf_fill_buffer(qfl, curbuf, NULL); 4142 4143 decr_quickfix_busy(); 4144 4145 curwin->w_cursor.lnum = lnum; 4146 curwin->w_cursor.col = 0; 4147 check_cursor(); 4148 update_topline(); // scroll to show the line 4149 } 4150 4151 /* 4152 * Move the cursor in the quickfix window to "lnum". 4153 */ 4154 static void 4155 qf_win_goto(win_T *win, linenr_T lnum) 4156 { 4157 win_T *old_curwin = curwin; 4158 4159 curwin = win; 4160 curbuf = win->w_buffer; 4161 curwin->w_cursor.lnum = lnum; 4162 curwin->w_cursor.col = 0; 4163 curwin->w_cursor.coladd = 0; 4164 curwin->w_curswant = 0; 4165 update_topline(); // scroll to show the line 4166 redraw_later(VALID); 4167 curwin->w_redr_status = TRUE; // update ruler 4168 curwin = old_curwin; 4169 curbuf = curwin->w_buffer; 4170 } 4171 4172 /* 4173 * :cbottom/:lbottom commands. 4174 */ 4175 void 4176 ex_cbottom(exarg_T *eap) 4177 { 4178 qf_info_T *qi = &ql_info; 4179 win_T *win; 4180 4181 if (is_loclist_cmd(eap->cmdidx)) 4182 { 4183 qi = GET_LOC_LIST(curwin); 4184 if (qi == NULL) 4185 { 4186 emsg(_(e_loclist)); 4187 return; 4188 } 4189 } 4190 4191 win = qf_find_win(qi); 4192 if (win != NULL && win->w_cursor.lnum != win->w_buffer->b_ml.ml_line_count) 4193 qf_win_goto(win, win->w_buffer->b_ml.ml_line_count); 4194 } 4195 4196 /* 4197 * Return the number of the current entry (line number in the quickfix 4198 * window). 4199 */ 4200 linenr_T 4201 qf_current_entry(win_T *wp) 4202 { 4203 qf_info_T *qi = &ql_info; 4204 4205 if (IS_LL_WINDOW(wp)) 4206 // In the location list window, use the referenced location list 4207 qi = wp->w_llist_ref; 4208 4209 return qf_get_curlist(qi)->qf_index; 4210 } 4211 4212 /* 4213 * Update the cursor position in the quickfix window to the current error. 4214 * Return TRUE if there is a quickfix window. 4215 */ 4216 static int 4217 qf_win_pos_update( 4218 qf_info_T *qi, 4219 int old_qf_index) // previous qf_index or zero 4220 { 4221 win_T *win; 4222 int qf_index = qf_get_curlist(qi)->qf_index; 4223 4224 // Put the cursor on the current error in the quickfix window, so that 4225 // it's viewable. 4226 win = qf_find_win(qi); 4227 if (win != NULL 4228 && qf_index <= win->w_buffer->b_ml.ml_line_count 4229 && old_qf_index != qf_index) 4230 { 4231 if (qf_index > old_qf_index) 4232 { 4233 win->w_redraw_top = old_qf_index; 4234 win->w_redraw_bot = qf_index; 4235 } 4236 else 4237 { 4238 win->w_redraw_top = qf_index; 4239 win->w_redraw_bot = old_qf_index; 4240 } 4241 qf_win_goto(win, qf_index); 4242 } 4243 return win != NULL; 4244 } 4245 4246 /* 4247 * Check whether the given window is displaying the specified quickfix/location 4248 * stack. 4249 */ 4250 static int 4251 is_qf_win(win_T *win, qf_info_T *qi) 4252 { 4253 // A window displaying the quickfix buffer will have the w_llist_ref field 4254 // set to NULL. 4255 // A window displaying a location list buffer will have the w_llist_ref 4256 // pointing to the location list. 4257 if (bt_quickfix(win->w_buffer)) 4258 if ((IS_QF_STACK(qi) && win->w_llist_ref == NULL) 4259 || (IS_LL_STACK(qi) && win->w_llist_ref == qi)) 4260 return TRUE; 4261 4262 return FALSE; 4263 } 4264 4265 /* 4266 * Find a window displaying the quickfix/location stack 'qi' 4267 * Only searches in the current tabpage. 4268 */ 4269 static win_T * 4270 qf_find_win(qf_info_T *qi) 4271 { 4272 win_T *win; 4273 4274 FOR_ALL_WINDOWS(win) 4275 if (is_qf_win(win, qi)) 4276 return win; 4277 return NULL; 4278 } 4279 4280 /* 4281 * Find a quickfix buffer. 4282 * Searches in windows opened in all the tabs. 4283 */ 4284 static buf_T * 4285 qf_find_buf(qf_info_T *qi) 4286 { 4287 tabpage_T *tp; 4288 win_T *win; 4289 4290 if (qi->qf_bufnr != INVALID_QFBUFNR) 4291 { 4292 buf_T *qfbuf; 4293 qfbuf = buflist_findnr(qi->qf_bufnr); 4294 if (qfbuf != NULL) 4295 return qfbuf; 4296 // buffer is no longer present 4297 qi->qf_bufnr = INVALID_QFBUFNR; 4298 } 4299 4300 FOR_ALL_TAB_WINDOWS(tp, win) 4301 if (is_qf_win(win, qi)) 4302 return win->w_buffer; 4303 4304 return NULL; 4305 } 4306 4307 /* 4308 * Update the w:quickfix_title variable in the quickfix/location list window 4309 */ 4310 static void 4311 qf_update_win_titlevar(qf_info_T *qi) 4312 { 4313 win_T *win; 4314 win_T *curwin_save; 4315 4316 if ((win = qf_find_win(qi)) != NULL) 4317 { 4318 curwin_save = curwin; 4319 curwin = win; 4320 qf_set_title_var(qf_get_curlist(qi)); 4321 curwin = curwin_save; 4322 } 4323 } 4324 4325 /* 4326 * Find the quickfix buffer. If it exists, update the contents. 4327 */ 4328 static void 4329 qf_update_buffer(qf_info_T *qi, qfline_T *old_last) 4330 { 4331 buf_T *buf; 4332 win_T *win; 4333 aco_save_T aco; 4334 4335 // Check if a buffer for the quickfix list exists. Update it. 4336 buf = qf_find_buf(qi); 4337 if (buf != NULL) 4338 { 4339 linenr_T old_line_count = buf->b_ml.ml_line_count; 4340 4341 if (old_last == NULL) 4342 // set curwin/curbuf to buf and save a few things 4343 aucmd_prepbuf(&aco, buf); 4344 4345 qf_update_win_titlevar(qi); 4346 4347 qf_fill_buffer(qf_get_curlist(qi), buf, old_last); 4348 ++CHANGEDTICK(buf); 4349 4350 if (old_last == NULL) 4351 { 4352 (void)qf_win_pos_update(qi, 0); 4353 4354 // restore curwin/curbuf and a few other things 4355 aucmd_restbuf(&aco); 4356 } 4357 4358 // Only redraw when added lines are visible. This avoids flickering 4359 // when the added lines are not visible. 4360 if ((win = qf_find_win(qi)) != NULL && old_line_count < win->w_botline) 4361 redraw_buf_later(buf, NOT_VALID); 4362 } 4363 } 4364 4365 /* 4366 * Add an error line to the quickfix buffer. 4367 */ 4368 static int 4369 qf_buf_add_line(buf_T *buf, linenr_T lnum, qfline_T *qfp, char_u *dirname) 4370 { 4371 int len; 4372 buf_T *errbuf; 4373 4374 if (qfp->qf_module != NULL) 4375 { 4376 STRCPY(IObuff, qfp->qf_module); 4377 len = (int)STRLEN(IObuff); 4378 } 4379 else if (qfp->qf_fnum != 0 4380 && (errbuf = buflist_findnr(qfp->qf_fnum)) != NULL 4381 && errbuf->b_fname != NULL) 4382 { 4383 if (qfp->qf_type == 1) // :helpgrep 4384 STRCPY(IObuff, gettail(errbuf->b_fname)); 4385 else 4386 { 4387 // shorten the file name if not done already 4388 if (errbuf->b_sfname == NULL 4389 || mch_isFullName(errbuf->b_sfname)) 4390 { 4391 if (*dirname == NUL) 4392 mch_dirname(dirname, MAXPATHL); 4393 shorten_buf_fname(errbuf, dirname, FALSE); 4394 } 4395 STRCPY(IObuff, errbuf->b_fname); 4396 } 4397 len = (int)STRLEN(IObuff); 4398 } 4399 else 4400 len = 0; 4401 IObuff[len++] = '|'; 4402 4403 if (qfp->qf_lnum > 0) 4404 { 4405 sprintf((char *)IObuff + len, "%ld", qfp->qf_lnum); 4406 len += (int)STRLEN(IObuff + len); 4407 4408 if (qfp->qf_col > 0) 4409 { 4410 sprintf((char *)IObuff + len, " col %d", qfp->qf_col); 4411 len += (int)STRLEN(IObuff + len); 4412 } 4413 4414 sprintf((char *)IObuff + len, "%s", 4415 (char *)qf_types(qfp->qf_type, qfp->qf_nr)); 4416 len += (int)STRLEN(IObuff + len); 4417 } 4418 else if (qfp->qf_pattern != NULL) 4419 { 4420 qf_fmt_text(qfp->qf_pattern, IObuff + len, IOSIZE - len); 4421 len += (int)STRLEN(IObuff + len); 4422 } 4423 IObuff[len++] = '|'; 4424 IObuff[len++] = ' '; 4425 4426 // Remove newlines and leading whitespace from the text. 4427 // For an unrecognized line keep the indent, the compiler may 4428 // mark a word with ^^^^. 4429 qf_fmt_text(len > 3 ? skipwhite(qfp->qf_text) : qfp->qf_text, 4430 IObuff + len, IOSIZE - len); 4431 4432 if (ml_append_buf(buf, lnum, IObuff, 4433 (colnr_T)STRLEN(IObuff) + 1, FALSE) == FAIL) 4434 return FAIL; 4435 4436 return OK; 4437 } 4438 4439 /* 4440 * Fill current buffer with quickfix errors, replacing any previous contents. 4441 * curbuf must be the quickfix buffer! 4442 * If "old_last" is not NULL append the items after this one. 4443 * When "old_last" is NULL then "buf" must equal "curbuf"! Because 4444 * ml_delete() is used and autocommands will be triggered. 4445 */ 4446 static void 4447 qf_fill_buffer(qf_list_T *qfl, buf_T *buf, qfline_T *old_last) 4448 { 4449 linenr_T lnum; 4450 qfline_T *qfp; 4451 int old_KeyTyped = KeyTyped; 4452 4453 if (old_last == NULL) 4454 { 4455 if (buf != curbuf) 4456 { 4457 internal_error("qf_fill_buffer()"); 4458 return; 4459 } 4460 4461 // delete all existing lines 4462 while ((curbuf->b_ml.ml_flags & ML_EMPTY) == 0) 4463 (void)ml_delete((linenr_T)1, FALSE); 4464 } 4465 4466 // Check if there is anything to display 4467 if (qfl != NULL) 4468 { 4469 char_u dirname[MAXPATHL]; 4470 4471 *dirname = NUL; 4472 4473 // Add one line for each error 4474 if (old_last == NULL) 4475 { 4476 qfp = qfl->qf_start; 4477 lnum = 0; 4478 } 4479 else 4480 { 4481 qfp = old_last->qf_next; 4482 lnum = buf->b_ml.ml_line_count; 4483 } 4484 while (lnum < qfl->qf_count) 4485 { 4486 if (qf_buf_add_line(buf, lnum, qfp, dirname) == FAIL) 4487 break; 4488 4489 ++lnum; 4490 qfp = qfp->qf_next; 4491 if (qfp == NULL) 4492 break; 4493 } 4494 4495 if (old_last == NULL) 4496 // Delete the empty line which is now at the end 4497 (void)ml_delete(lnum + 1, FALSE); 4498 } 4499 4500 // correct cursor position 4501 check_lnums(TRUE); 4502 4503 if (old_last == NULL) 4504 { 4505 // Set the 'filetype' to "qf" each time after filling the buffer. 4506 // This resembles reading a file into a buffer, it's more logical when 4507 // using autocommands. 4508 ++curbuf_lock; 4509 set_option_value((char_u *)"ft", 0L, (char_u *)"qf", OPT_LOCAL); 4510 curbuf->b_p_ma = FALSE; 4511 4512 keep_filetype = TRUE; // don't detect 'filetype' 4513 apply_autocmds(EVENT_BUFREADPOST, (char_u *)"quickfix", NULL, 4514 FALSE, curbuf); 4515 apply_autocmds(EVENT_BUFWINENTER, (char_u *)"quickfix", NULL, 4516 FALSE, curbuf); 4517 keep_filetype = FALSE; 4518 --curbuf_lock; 4519 4520 // make sure it will be redrawn 4521 redraw_curbuf_later(NOT_VALID); 4522 } 4523 4524 // Restore KeyTyped, setting 'filetype' may reset it. 4525 KeyTyped = old_KeyTyped; 4526 } 4527 4528 /* 4529 * For every change made to the quickfix list, update the changed tick. 4530 */ 4531 static void 4532 qf_list_changed(qf_list_T *qfl) 4533 { 4534 qfl->qf_changedtick++; 4535 } 4536 4537 /* 4538 * Return the quickfix/location list number with the given identifier. 4539 * Returns -1 if list is not found. 4540 */ 4541 static int 4542 qf_id2nr(qf_info_T *qi, int_u qfid) 4543 { 4544 int qf_idx; 4545 4546 for (qf_idx = 0; qf_idx < qi->qf_listcount; qf_idx++) 4547 if (qi->qf_lists[qf_idx].qf_id == qfid) 4548 return qf_idx; 4549 return INVALID_QFIDX; 4550 } 4551 4552 /* 4553 * If the current list is not "save_qfid" and we can find the list with that ID 4554 * then make it the current list. 4555 * This is used when autocommands may have changed the current list. 4556 * Returns OK if successfully restored the list. Returns FAIL if the list with 4557 * the specified identifier (save_qfid) is not found in the stack. 4558 */ 4559 static int 4560 qf_restore_list(qf_info_T *qi, int_u save_qfid) 4561 { 4562 int curlist; 4563 4564 if (qf_get_curlist(qi)->qf_id != save_qfid) 4565 { 4566 curlist = qf_id2nr(qi, save_qfid); 4567 if (curlist < 0) 4568 // list is not present 4569 return FAIL; 4570 qi->qf_curlist = curlist; 4571 } 4572 return OK; 4573 } 4574 4575 /* 4576 * Jump to the first entry if there is one. 4577 */ 4578 static void 4579 qf_jump_first(qf_info_T *qi, int_u save_qfid, int forceit) 4580 { 4581 if (qf_restore_list(qi, save_qfid) == FAIL) 4582 return; 4583 4584 // Autocommands might have cleared the list, check for that. 4585 if (!qf_list_empty(qf_get_curlist(qi))) 4586 qf_jump(qi, 0, 0, forceit); 4587 } 4588 4589 /* 4590 * Return TRUE when using ":vimgrep" for ":grep". 4591 */ 4592 int 4593 grep_internal(cmdidx_T cmdidx) 4594 { 4595 return ((cmdidx == CMD_grep 4596 || cmdidx == CMD_lgrep 4597 || cmdidx == CMD_grepadd 4598 || cmdidx == CMD_lgrepadd) 4599 && STRCMP("internal", 4600 *curbuf->b_p_gp == NUL ? p_gp : curbuf->b_p_gp) == 0); 4601 } 4602 4603 /* 4604 * Return the make/grep autocmd name. 4605 */ 4606 static char_u * 4607 make_get_auname(cmdidx_T cmdidx) 4608 { 4609 switch (cmdidx) 4610 { 4611 case CMD_make: return (char_u *)"make"; 4612 case CMD_lmake: return (char_u *)"lmake"; 4613 case CMD_grep: return (char_u *)"grep"; 4614 case CMD_lgrep: return (char_u *)"lgrep"; 4615 case CMD_grepadd: return (char_u *)"grepadd"; 4616 case CMD_lgrepadd: return (char_u *)"lgrepadd"; 4617 default: return NULL; 4618 } 4619 } 4620 4621 /* 4622 * Return the name for the errorfile, in allocated memory. 4623 * Find a new unique name when 'makeef' contains "##". 4624 * Returns NULL for error. 4625 */ 4626 static char_u * 4627 get_mef_name(void) 4628 { 4629 char_u *p; 4630 char_u *name; 4631 static int start = -1; 4632 static int off = 0; 4633 #ifdef HAVE_LSTAT 4634 stat_T sb; 4635 #endif 4636 4637 if (*p_mef == NUL) 4638 { 4639 name = vim_tempname('e', FALSE); 4640 if (name == NULL) 4641 emsg(_(e_notmp)); 4642 return name; 4643 } 4644 4645 for (p = p_mef; *p; ++p) 4646 if (p[0] == '#' && p[1] == '#') 4647 break; 4648 4649 if (*p == NUL) 4650 return vim_strsave(p_mef); 4651 4652 // Keep trying until the name doesn't exist yet. 4653 for (;;) 4654 { 4655 if (start == -1) 4656 start = mch_get_pid(); 4657 else 4658 off += 19; 4659 4660 name = alloc((unsigned)STRLEN(p_mef) + 30); 4661 if (name == NULL) 4662 break; 4663 STRCPY(name, p_mef); 4664 sprintf((char *)name + (p - p_mef), "%d%d", start, off); 4665 STRCAT(name, p + 2); 4666 if (mch_getperm(name) < 0 4667 #ifdef HAVE_LSTAT 4668 // Don't accept a symbolic link, it's a security risk. 4669 && mch_lstat((char *)name, &sb) < 0 4670 #endif 4671 ) 4672 break; 4673 vim_free(name); 4674 } 4675 return name; 4676 } 4677 4678 /* 4679 * Form the complete command line to invoke 'make'/'grep'. Quote the command 4680 * using 'shellquote' and append 'shellpipe'. Echo the fully formed command. 4681 */ 4682 static char_u * 4683 make_get_fullcmd(char_u *makecmd, char_u *fname) 4684 { 4685 char_u *cmd; 4686 unsigned len; 4687 4688 len = (unsigned)STRLEN(p_shq) * 2 + (unsigned)STRLEN(makecmd) + 1; 4689 if (*p_sp != NUL) 4690 len += (unsigned)STRLEN(p_sp) + (unsigned)STRLEN(fname) + 3; 4691 cmd = alloc(len); 4692 if (cmd == NULL) 4693 return NULL; 4694 sprintf((char *)cmd, "%s%s%s", (char *)p_shq, (char *)makecmd, 4695 (char *)p_shq); 4696 4697 // If 'shellpipe' empty: don't redirect to 'errorfile'. 4698 if (*p_sp != NUL) 4699 append_redir(cmd, len, p_sp, fname); 4700 4701 // Display the fully formed command. Output a newline if there's something 4702 // else than the :make command that was typed (in which case the cursor is 4703 // in column 0). 4704 if (msg_col == 0) 4705 msg_didout = FALSE; 4706 msg_start(); 4707 msg_puts(":!"); 4708 msg_outtrans(cmd); // show what we are doing 4709 4710 return cmd; 4711 } 4712 4713 /* 4714 * Used for ":make", ":lmake", ":grep", ":lgrep", ":grepadd", and ":lgrepadd" 4715 */ 4716 void 4717 ex_make(exarg_T *eap) 4718 { 4719 char_u *fname; 4720 char_u *cmd; 4721 char_u *enc = NULL; 4722 win_T *wp = NULL; 4723 qf_info_T *qi = &ql_info; 4724 int res; 4725 char_u *au_name = NULL; 4726 int_u save_qfid; 4727 4728 // Redirect ":grep" to ":vimgrep" if 'grepprg' is "internal". 4729 if (grep_internal(eap->cmdidx)) 4730 { 4731 ex_vimgrep(eap); 4732 return; 4733 } 4734 4735 au_name = make_get_auname(eap->cmdidx); 4736 if (au_name != NULL && apply_autocmds(EVENT_QUICKFIXCMDPRE, au_name, 4737 curbuf->b_fname, TRUE, curbuf)) 4738 { 4739 #ifdef FEAT_EVAL 4740 if (aborting()) 4741 return; 4742 #endif 4743 } 4744 enc = (*curbuf->b_p_menc != NUL) ? curbuf->b_p_menc : p_menc; 4745 4746 if (is_loclist_cmd(eap->cmdidx)) 4747 wp = curwin; 4748 4749 autowrite_all(); 4750 fname = get_mef_name(); 4751 if (fname == NULL) 4752 return; 4753 mch_remove(fname); // in case it's not unique 4754 4755 cmd = make_get_fullcmd(eap->arg, fname); 4756 if (cmd == NULL) 4757 return; 4758 4759 // let the shell know if we are redirecting output or not 4760 do_shell(cmd, *p_sp != NUL ? SHELL_DOOUT : 0); 4761 4762 #ifdef AMIGA 4763 out_flush(); 4764 // read window status report and redraw before message 4765 (void)char_avail(); 4766 #endif 4767 4768 incr_quickfix_busy(); 4769 4770 res = qf_init(wp, fname, (eap->cmdidx != CMD_make 4771 && eap->cmdidx != CMD_lmake) ? p_gefm : p_efm, 4772 (eap->cmdidx != CMD_grepadd 4773 && eap->cmdidx != CMD_lgrepadd), 4774 qf_cmdtitle(*eap->cmdlinep), enc); 4775 if (wp != NULL) 4776 { 4777 qi = GET_LOC_LIST(wp); 4778 if (qi == NULL) 4779 goto cleanup; 4780 } 4781 if (res >= 0) 4782 qf_list_changed(qf_get_curlist(qi)); 4783 4784 // Remember the current quickfix list identifier, so that we can 4785 // check for autocommands changing the current quickfix list. 4786 save_qfid = qf_get_curlist(qi)->qf_id; 4787 if (au_name != NULL) 4788 apply_autocmds(EVENT_QUICKFIXCMDPOST, au_name, 4789 curbuf->b_fname, TRUE, curbuf); 4790 if (res > 0 && !eap->forceit && qflist_valid(wp, save_qfid)) 4791 // display the first error 4792 qf_jump_first(qi, save_qfid, FALSE); 4793 4794 cleanup: 4795 decr_quickfix_busy(); 4796 mch_remove(fname); 4797 vim_free(fname); 4798 vim_free(cmd); 4799 } 4800 4801 /* 4802 * Returns the number of valid entries in the current quickfix/location list. 4803 */ 4804 int 4805 qf_get_size(exarg_T *eap) 4806 { 4807 qf_info_T *qi = &ql_info; 4808 qf_list_T *qfl; 4809 qfline_T *qfp; 4810 int i, sz = 0; 4811 int prev_fnum = 0; 4812 4813 if (is_loclist_cmd(eap->cmdidx)) 4814 { 4815 // Location list 4816 qi = GET_LOC_LIST(curwin); 4817 if (qi == NULL) 4818 return 0; 4819 } 4820 4821 qfl = qf_get_curlist(qi); 4822 for (i = 0, qfp = qfl->qf_start; i < qfl->qf_count && qfp != NULL; 4823 ++i, qfp = qfp->qf_next) 4824 { 4825 if (qfp->qf_valid) 4826 { 4827 if (eap->cmdidx == CMD_cdo || eap->cmdidx == CMD_ldo) 4828 sz++; // Count all valid entries 4829 else if (qfp->qf_fnum > 0 && qfp->qf_fnum != prev_fnum) 4830 { 4831 // Count the number of files 4832 sz++; 4833 prev_fnum = qfp->qf_fnum; 4834 } 4835 } 4836 } 4837 4838 return sz; 4839 } 4840 4841 /* 4842 * Returns the current index of the quickfix/location list. 4843 * Returns 0 if there is an error. 4844 */ 4845 int 4846 qf_get_cur_idx(exarg_T *eap) 4847 { 4848 qf_info_T *qi = &ql_info; 4849 4850 if (is_loclist_cmd(eap->cmdidx)) 4851 { 4852 // Location list 4853 qi = GET_LOC_LIST(curwin); 4854 if (qi == NULL) 4855 return 0; 4856 } 4857 4858 return qf_get_curlist(qi)->qf_index; 4859 } 4860 4861 /* 4862 * Returns the current index in the quickfix/location list (counting only valid 4863 * entries). If no valid entries are in the list, then returns 1. 4864 */ 4865 int 4866 qf_get_cur_valid_idx(exarg_T *eap) 4867 { 4868 qf_info_T *qi = &ql_info; 4869 qf_list_T *qfl; 4870 qfline_T *qfp; 4871 int i, eidx = 0; 4872 int prev_fnum = 0; 4873 4874 if (is_loclist_cmd(eap->cmdidx)) 4875 { 4876 // Location list 4877 qi = GET_LOC_LIST(curwin); 4878 if (qi == NULL) 4879 return 1; 4880 } 4881 4882 qfl = qf_get_curlist(qi); 4883 qfp = qfl->qf_start; 4884 4885 // check if the list has valid errors 4886 if (qfl->qf_count <= 0 || qfl->qf_nonevalid) 4887 return 1; 4888 4889 for (i = 1; i <= qfl->qf_index && qfp!= NULL; i++, qfp = qfp->qf_next) 4890 { 4891 if (qfp->qf_valid) 4892 { 4893 if (eap->cmdidx == CMD_cfdo || eap->cmdidx == CMD_lfdo) 4894 { 4895 if (qfp->qf_fnum > 0 && qfp->qf_fnum != prev_fnum) 4896 { 4897 // Count the number of files 4898 eidx++; 4899 prev_fnum = qfp->qf_fnum; 4900 } 4901 } 4902 else 4903 eidx++; 4904 } 4905 } 4906 4907 return eidx ? eidx : 1; 4908 } 4909 4910 /* 4911 * Get the 'n'th valid error entry in the quickfix or location list. 4912 * Used by :cdo, :ldo, :cfdo and :lfdo commands. 4913 * For :cdo and :ldo returns the 'n'th valid error entry. 4914 * For :cfdo and :lfdo returns the 'n'th valid file entry. 4915 */ 4916 static int 4917 qf_get_nth_valid_entry(qf_list_T *qfl, int n, int fdo) 4918 { 4919 qfline_T *qfp = qfl->qf_start; 4920 int i, eidx; 4921 int prev_fnum = 0; 4922 4923 // check if the list has valid errors 4924 if (qfl->qf_count <= 0 || qfl->qf_nonevalid) 4925 return 1; 4926 4927 for (i = 1, eidx = 0; i <= qfl->qf_count && qfp != NULL; 4928 i++, qfp = qfp->qf_next) 4929 { 4930 if (qfp->qf_valid) 4931 { 4932 if (fdo) 4933 { 4934 if (qfp->qf_fnum > 0 && qfp->qf_fnum != prev_fnum) 4935 { 4936 // Count the number of files 4937 eidx++; 4938 prev_fnum = qfp->qf_fnum; 4939 } 4940 } 4941 else 4942 eidx++; 4943 } 4944 4945 if (eidx == n) 4946 break; 4947 } 4948 4949 if (i <= qfl->qf_count) 4950 return i; 4951 else 4952 return 1; 4953 } 4954 4955 /* 4956 * ":cc", ":crewind", ":cfirst" and ":clast". 4957 * ":ll", ":lrewind", ":lfirst" and ":llast". 4958 * ":cdo", ":ldo", ":cfdo" and ":lfdo" 4959 */ 4960 void 4961 ex_cc(exarg_T *eap) 4962 { 4963 qf_info_T *qi = &ql_info; 4964 int errornr; 4965 4966 if (is_loclist_cmd(eap->cmdidx)) 4967 { 4968 qi = GET_LOC_LIST(curwin); 4969 if (qi == NULL) 4970 { 4971 emsg(_(e_loclist)); 4972 return; 4973 } 4974 } 4975 4976 if (eap->addr_count > 0) 4977 errornr = (int)eap->line2; 4978 else 4979 { 4980 switch (eap->cmdidx) 4981 { 4982 case CMD_cc: case CMD_ll: 4983 errornr = 0; 4984 break; 4985 case CMD_crewind: case CMD_lrewind: case CMD_cfirst: 4986 case CMD_lfirst: 4987 errornr = 1; 4988 break; 4989 default: 4990 errornr = 32767; 4991 } 4992 } 4993 4994 // For cdo and ldo commands, jump to the nth valid error. 4995 // For cfdo and lfdo commands, jump to the nth valid file entry. 4996 if (eap->cmdidx == CMD_cdo || eap->cmdidx == CMD_ldo 4997 || eap->cmdidx == CMD_cfdo || eap->cmdidx == CMD_lfdo) 4998 errornr = qf_get_nth_valid_entry(qf_get_curlist(qi), 4999 eap->addr_count > 0 ? (int)eap->line1 : 1, 5000 eap->cmdidx == CMD_cfdo || eap->cmdidx == CMD_lfdo); 5001 5002 qf_jump(qi, 0, errornr, eap->forceit); 5003 } 5004 5005 /* 5006 * ":cnext", ":cnfile", ":cNext" and ":cprevious". 5007 * ":lnext", ":lNext", ":lprevious", ":lnfile", ":lNfile" and ":lpfile". 5008 * Also, used by ":cdo", ":ldo", ":cfdo" and ":lfdo" commands. 5009 */ 5010 void 5011 ex_cnext(exarg_T *eap) 5012 { 5013 qf_info_T *qi = &ql_info; 5014 int errornr; 5015 int dir; 5016 5017 if (is_loclist_cmd(eap->cmdidx)) 5018 { 5019 qi = GET_LOC_LIST(curwin); 5020 if (qi == NULL) 5021 { 5022 emsg(_(e_loclist)); 5023 return; 5024 } 5025 } 5026 5027 if (eap->addr_count > 0 5028 && (eap->cmdidx != CMD_cdo && eap->cmdidx != CMD_ldo 5029 && eap->cmdidx != CMD_cfdo && eap->cmdidx != CMD_lfdo)) 5030 errornr = (int)eap->line2; 5031 else 5032 errornr = 1; 5033 5034 // Depending on the command jump to either next or previous entry/file. 5035 switch (eap->cmdidx) 5036 { 5037 case CMD_cnext: case CMD_lnext: case CMD_cdo: case CMD_ldo: 5038 dir = FORWARD; 5039 break; 5040 case CMD_cprevious: case CMD_lprevious: case CMD_cNext: 5041 case CMD_lNext: 5042 dir = BACKWARD; 5043 break; 5044 case CMD_cnfile: case CMD_lnfile: case CMD_cfdo: case CMD_lfdo: 5045 dir = FORWARD_FILE; 5046 break; 5047 case CMD_cpfile: case CMD_lpfile: case CMD_cNfile: case CMD_lNfile: 5048 dir = BACKWARD_FILE; 5049 break; 5050 default: 5051 dir = FORWARD; 5052 break; 5053 } 5054 5055 qf_jump(qi, dir, errornr, eap->forceit); 5056 } 5057 5058 /* 5059 * ":cfile"/":cgetfile"/":caddfile" commands. 5060 * ":lfile"/":lgetfile"/":laddfile" commands. 5061 */ 5062 void 5063 ex_cfile(exarg_T *eap) 5064 { 5065 char_u *enc = NULL; 5066 win_T *wp = NULL; 5067 qf_info_T *qi = &ql_info; 5068 char_u *au_name = NULL; 5069 int_u save_qfid = 0; // init for gcc 5070 int res; 5071 5072 switch (eap->cmdidx) 5073 { 5074 case CMD_cfile: au_name = (char_u *)"cfile"; break; 5075 case CMD_cgetfile: au_name = (char_u *)"cgetfile"; break; 5076 case CMD_caddfile: au_name = (char_u *)"caddfile"; break; 5077 case CMD_lfile: au_name = (char_u *)"lfile"; break; 5078 case CMD_lgetfile: au_name = (char_u *)"lgetfile"; break; 5079 case CMD_laddfile: au_name = (char_u *)"laddfile"; break; 5080 default: break; 5081 } 5082 if (au_name != NULL) 5083 apply_autocmds(EVENT_QUICKFIXCMDPRE, au_name, NULL, FALSE, curbuf); 5084 enc = (*curbuf->b_p_menc != NUL) ? curbuf->b_p_menc : p_menc; 5085 #ifdef FEAT_BROWSE 5086 if (cmdmod.browse) 5087 { 5088 char_u *browse_file = do_browse(0, (char_u *)_("Error file"), eap->arg, 5089 NULL, NULL, 5090 (char_u *)_(BROWSE_FILTER_ALL_FILES), NULL); 5091 if (browse_file == NULL) 5092 return; 5093 set_string_option_direct((char_u *)"ef", -1, browse_file, OPT_FREE, 0); 5094 vim_free(browse_file); 5095 } 5096 else 5097 #endif 5098 if (*eap->arg != NUL) 5099 set_string_option_direct((char_u *)"ef", -1, eap->arg, OPT_FREE, 0); 5100 5101 if (is_loclist_cmd(eap->cmdidx)) 5102 wp = curwin; 5103 5104 incr_quickfix_busy(); 5105 5106 // This function is used by the :cfile, :cgetfile and :caddfile 5107 // commands. 5108 // :cfile always creates a new quickfix list and jumps to the 5109 // first error. 5110 // :cgetfile creates a new quickfix list but doesn't jump to the 5111 // first error. 5112 // :caddfile adds to an existing quickfix list. If there is no 5113 // quickfix list then a new list is created. 5114 res = qf_init(wp, p_ef, p_efm, (eap->cmdidx != CMD_caddfile 5115 && eap->cmdidx != CMD_laddfile), 5116 qf_cmdtitle(*eap->cmdlinep), enc); 5117 if (wp != NULL) 5118 { 5119 qi = GET_LOC_LIST(wp); 5120 if (qi == NULL) 5121 { 5122 decr_quickfix_busy(); 5123 return; 5124 } 5125 } 5126 if (res >= 0) 5127 qf_list_changed(qf_get_curlist(qi)); 5128 save_qfid = qf_get_curlist(qi)->qf_id; 5129 if (au_name != NULL) 5130 apply_autocmds(EVENT_QUICKFIXCMDPOST, au_name, NULL, FALSE, curbuf); 5131 5132 // Jump to the first error for a new list and if autocmds didn't 5133 // free the list. 5134 if (res > 0 && (eap->cmdidx == CMD_cfile || eap->cmdidx == CMD_lfile) 5135 && qflist_valid(wp, save_qfid)) 5136 // display the first error 5137 qf_jump_first(qi, save_qfid, eap->forceit); 5138 5139 decr_quickfix_busy(); 5140 } 5141 5142 /* 5143 * Return the vimgrep autocmd name. 5144 */ 5145 static char_u * 5146 vgr_get_auname(cmdidx_T cmdidx) 5147 { 5148 switch (cmdidx) 5149 { 5150 case CMD_vimgrep: return (char_u *)"vimgrep"; 5151 case CMD_lvimgrep: return (char_u *)"lvimgrep"; 5152 case CMD_vimgrepadd: return (char_u *)"vimgrepadd"; 5153 case CMD_lvimgrepadd: return (char_u *)"lvimgrepadd"; 5154 case CMD_grep: return (char_u *)"grep"; 5155 case CMD_lgrep: return (char_u *)"lgrep"; 5156 case CMD_grepadd: return (char_u *)"grepadd"; 5157 case CMD_lgrepadd: return (char_u *)"lgrepadd"; 5158 default: return NULL; 5159 } 5160 } 5161 5162 /* 5163 * Initialize the regmatch used by vimgrep for pattern "s". 5164 */ 5165 static void 5166 vgr_init_regmatch(regmmatch_T *regmatch, char_u *s) 5167 { 5168 // Get the search pattern: either white-separated or enclosed in // 5169 regmatch->regprog = NULL; 5170 5171 if (s == NULL || *s == NUL) 5172 { 5173 // Pattern is empty, use last search pattern. 5174 if (last_search_pat() == NULL) 5175 { 5176 emsg(_(e_noprevre)); 5177 return; 5178 } 5179 regmatch->regprog = vim_regcomp(last_search_pat(), RE_MAGIC); 5180 } 5181 else 5182 regmatch->regprog = vim_regcomp(s, RE_MAGIC); 5183 5184 regmatch->rmm_ic = p_ic; 5185 regmatch->rmm_maxcol = 0; 5186 } 5187 5188 /* 5189 * Display a file name when vimgrep is running. 5190 */ 5191 static void 5192 vgr_display_fname(char_u *fname) 5193 { 5194 char_u *p; 5195 5196 msg_start(); 5197 p = msg_strtrunc(fname, TRUE); 5198 if (p == NULL) 5199 msg_outtrans(fname); 5200 else 5201 { 5202 msg_outtrans(p); 5203 vim_free(p); 5204 } 5205 msg_clr_eos(); 5206 msg_didout = FALSE; // overwrite this message 5207 msg_nowait = TRUE; // don't wait for this message 5208 msg_col = 0; 5209 out_flush(); 5210 } 5211 5212 /* 5213 * Load a dummy buffer to search for a pattern using vimgrep. 5214 */ 5215 static buf_T * 5216 vgr_load_dummy_buf( 5217 char_u *fname, 5218 char_u *dirname_start, 5219 char_u *dirname_now) 5220 { 5221 int save_mls; 5222 #if defined(FEAT_SYN_HL) 5223 char_u *save_ei = NULL; 5224 #endif 5225 buf_T *buf; 5226 5227 #if defined(FEAT_SYN_HL) 5228 // Don't do Filetype autocommands to avoid loading syntax and 5229 // indent scripts, a great speed improvement. 5230 save_ei = au_event_disable(",Filetype"); 5231 #endif 5232 // Don't use modelines here, it's useless. 5233 save_mls = p_mls; 5234 p_mls = 0; 5235 5236 // Load file into a buffer, so that 'fileencoding' is detected, 5237 // autocommands applied, etc. 5238 buf = load_dummy_buffer(fname, dirname_start, dirname_now); 5239 5240 p_mls = save_mls; 5241 #if defined(FEAT_SYN_HL) 5242 au_event_restore(save_ei); 5243 #endif 5244 5245 return buf; 5246 } 5247 5248 /* 5249 * Check whether a quickfix/location list is valid. Autocmds may remove or 5250 * change a quickfix list when vimgrep is running. If the list is not found, 5251 * create a new list. 5252 */ 5253 static int 5254 vgr_qflist_valid( 5255 win_T *wp, 5256 qf_info_T *qi, 5257 int_u qfid, 5258 char_u *title) 5259 { 5260 // Verify that the quickfix/location list was not freed by an autocmd 5261 if (!qflist_valid(wp, qfid)) 5262 { 5263 if (wp != NULL) 5264 { 5265 // An autocmd has freed the location list. 5266 emsg(_(e_loc_list_changed)); 5267 return FALSE; 5268 } 5269 else 5270 { 5271 // Quickfix list is not found, create a new one. 5272 qf_new_list(qi, title); 5273 return TRUE; 5274 } 5275 } 5276 5277 if (qf_restore_list(qi, qfid) == FAIL) 5278 return FALSE; 5279 5280 return TRUE; 5281 } 5282 5283 /* 5284 * Search for a pattern in all the lines in a buffer and add the matching lines 5285 * to a quickfix list. 5286 */ 5287 static int 5288 vgr_match_buflines( 5289 qf_list_T *qfl, 5290 char_u *fname, 5291 buf_T *buf, 5292 regmmatch_T *regmatch, 5293 long *tomatch, 5294 int duplicate_name, 5295 int flags) 5296 { 5297 int found_match = FALSE; 5298 long lnum; 5299 colnr_T col; 5300 5301 for (lnum = 1; lnum <= buf->b_ml.ml_line_count && *tomatch > 0; ++lnum) 5302 { 5303 col = 0; 5304 while (vim_regexec_multi(regmatch, curwin, buf, lnum, 5305 col, NULL, NULL) > 0) 5306 { 5307 // Pass the buffer number so that it gets used even for a 5308 // dummy buffer, unless duplicate_name is set, then the 5309 // buffer will be wiped out below. 5310 if (qf_add_entry(qfl, 5311 NULL, // dir 5312 fname, 5313 NULL, 5314 duplicate_name ? 0 : buf->b_fnum, 5315 ml_get_buf(buf, 5316 regmatch->startpos[0].lnum + lnum, FALSE), 5317 regmatch->startpos[0].lnum + lnum, 5318 regmatch->startpos[0].col + 1, 5319 FALSE, // vis_col 5320 NULL, // search pattern 5321 0, // nr 5322 0, // type 5323 TRUE // valid 5324 ) == FAIL) 5325 { 5326 got_int = TRUE; 5327 break; 5328 } 5329 found_match = TRUE; 5330 if (--*tomatch == 0) 5331 break; 5332 if ((flags & VGR_GLOBAL) == 0 5333 || regmatch->endpos[0].lnum > 0) 5334 break; 5335 col = regmatch->endpos[0].col 5336 + (col == regmatch->endpos[0].col); 5337 if (col > (colnr_T)STRLEN(ml_get_buf(buf, lnum, FALSE))) 5338 break; 5339 } 5340 line_breakcheck(); 5341 if (got_int) 5342 break; 5343 } 5344 5345 return found_match; 5346 } 5347 5348 /* 5349 * Jump to the first match and update the directory. 5350 */ 5351 static void 5352 vgr_jump_to_match( 5353 qf_info_T *qi, 5354 int forceit, 5355 int *redraw_for_dummy, 5356 buf_T *first_match_buf, 5357 char_u *target_dir) 5358 { 5359 buf_T *buf; 5360 5361 buf = curbuf; 5362 qf_jump(qi, 0, 0, forceit); 5363 if (buf != curbuf) 5364 // If we jumped to another buffer redrawing will already be 5365 // taken care of. 5366 *redraw_for_dummy = FALSE; 5367 5368 // Jump to the directory used after loading the buffer. 5369 if (curbuf == first_match_buf && target_dir != NULL) 5370 { 5371 exarg_T ea; 5372 5373 ea.arg = target_dir; 5374 ea.cmdidx = CMD_lcd; 5375 ex_cd(&ea); 5376 } 5377 } 5378 5379 /* 5380 * ":vimgrep {pattern} file(s)" 5381 * ":vimgrepadd {pattern} file(s)" 5382 * ":lvimgrep {pattern} file(s)" 5383 * ":lvimgrepadd {pattern} file(s)" 5384 */ 5385 void 5386 ex_vimgrep(exarg_T *eap) 5387 { 5388 regmmatch_T regmatch; 5389 int fcount; 5390 char_u **fnames; 5391 char_u *fname; 5392 char_u *title; 5393 char_u *s; 5394 char_u *p; 5395 int fi; 5396 qf_info_T *qi = &ql_info; 5397 qf_list_T *qfl; 5398 int_u save_qfid; 5399 win_T *wp = NULL; 5400 buf_T *buf; 5401 int duplicate_name = FALSE; 5402 int using_dummy; 5403 int redraw_for_dummy = FALSE; 5404 int found_match; 5405 buf_T *first_match_buf = NULL; 5406 time_t seconds = 0; 5407 aco_save_T aco; 5408 int flags = 0; 5409 long tomatch; 5410 char_u *dirname_start = NULL; 5411 char_u *dirname_now = NULL; 5412 char_u *target_dir = NULL; 5413 char_u *au_name = NULL; 5414 5415 au_name = vgr_get_auname(eap->cmdidx); 5416 if (au_name != NULL && apply_autocmds(EVENT_QUICKFIXCMDPRE, au_name, 5417 curbuf->b_fname, TRUE, curbuf)) 5418 { 5419 #ifdef FEAT_EVAL 5420 if (aborting()) 5421 return; 5422 #endif 5423 } 5424 5425 if (is_loclist_cmd(eap->cmdidx)) 5426 { 5427 qi = ll_get_or_alloc_list(curwin); 5428 if (qi == NULL) 5429 return; 5430 wp = curwin; 5431 } 5432 5433 if (eap->addr_count > 0) 5434 tomatch = eap->line2; 5435 else 5436 tomatch = MAXLNUM; 5437 5438 // Get the search pattern: either white-separated or enclosed in // 5439 regmatch.regprog = NULL; 5440 title = vim_strsave(qf_cmdtitle(*eap->cmdlinep)); 5441 p = skip_vimgrep_pat(eap->arg, &s, &flags); 5442 if (p == NULL) 5443 { 5444 emsg(_(e_invalpat)); 5445 goto theend; 5446 } 5447 5448 vgr_init_regmatch(®match, s); 5449 if (regmatch.regprog == NULL) 5450 goto theend; 5451 5452 p = skipwhite(p); 5453 if (*p == NUL) 5454 { 5455 emsg(_("E683: File name missing or invalid pattern")); 5456 goto theend; 5457 } 5458 5459 if ((eap->cmdidx != CMD_grepadd && eap->cmdidx != CMD_lgrepadd 5460 && eap->cmdidx != CMD_vimgrepadd 5461 && eap->cmdidx != CMD_lvimgrepadd) 5462 || qf_stack_empty(qi)) 5463 // make place for a new list 5464 qf_new_list(qi, title != NULL ? title : qf_cmdtitle(*eap->cmdlinep)); 5465 5466 // parse the list of arguments 5467 if (get_arglist_exp(p, &fcount, &fnames, TRUE) == FAIL) 5468 goto theend; 5469 if (fcount == 0) 5470 { 5471 emsg(_(e_nomatch)); 5472 goto theend; 5473 } 5474 5475 dirname_start = alloc_id(MAXPATHL, aid_qf_dirname_start); 5476 dirname_now = alloc_id(MAXPATHL, aid_qf_dirname_now); 5477 if (dirname_start == NULL || dirname_now == NULL) 5478 { 5479 FreeWild(fcount, fnames); 5480 goto theend; 5481 } 5482 5483 // Remember the current directory, because a BufRead autocommand that does 5484 // ":lcd %:p:h" changes the meaning of short path names. 5485 mch_dirname(dirname_start, MAXPATHL); 5486 5487 incr_quickfix_busy(); 5488 5489 // Remember the current quickfix list identifier, so that we can check for 5490 // autocommands changing the current quickfix list. 5491 save_qfid = qf_get_curlist(qi)->qf_id; 5492 5493 seconds = (time_t)0; 5494 for (fi = 0; fi < fcount && !got_int && tomatch > 0; ++fi) 5495 { 5496 fname = shorten_fname1(fnames[fi]); 5497 if (time(NULL) > seconds) 5498 { 5499 // Display the file name every second or so, show the user we are 5500 // working on it. 5501 seconds = time(NULL); 5502 vgr_display_fname(fname); 5503 } 5504 5505 buf = buflist_findname_exp(fnames[fi]); 5506 if (buf == NULL || buf->b_ml.ml_mfp == NULL) 5507 { 5508 // Remember that a buffer with this name already exists. 5509 duplicate_name = (buf != NULL); 5510 using_dummy = TRUE; 5511 redraw_for_dummy = TRUE; 5512 5513 buf = vgr_load_dummy_buf(fname, dirname_start, dirname_now); 5514 } 5515 else 5516 // Use existing, loaded buffer. 5517 using_dummy = FALSE; 5518 5519 // Check whether the quickfix list is still valid. When loading a 5520 // buffer above, autocommands might have changed the quickfix list. 5521 if (!vgr_qflist_valid(wp, qi, save_qfid, qf_cmdtitle(*eap->cmdlinep))) 5522 { 5523 FreeWild(fcount, fnames); 5524 decr_quickfix_busy(); 5525 goto theend; 5526 } 5527 save_qfid = qf_get_curlist(qi)->qf_id; 5528 5529 if (buf == NULL) 5530 { 5531 if (!got_int) 5532 smsg(_("Cannot open file \"%s\""), fname); 5533 } 5534 else 5535 { 5536 // Try for a match in all lines of the buffer. 5537 // For ":1vimgrep" look for first match only. 5538 found_match = vgr_match_buflines(qf_get_curlist(qi), 5539 fname, buf, ®match, 5540 &tomatch, duplicate_name, flags); 5541 5542 if (using_dummy) 5543 { 5544 if (found_match && first_match_buf == NULL) 5545 first_match_buf = buf; 5546 if (duplicate_name) 5547 { 5548 // Never keep a dummy buffer if there is another buffer 5549 // with the same name. 5550 wipe_dummy_buffer(buf, dirname_start); 5551 buf = NULL; 5552 } 5553 else if (!cmdmod.hide 5554 || buf->b_p_bh[0] == 'u' // "unload" 5555 || buf->b_p_bh[0] == 'w' // "wipe" 5556 || buf->b_p_bh[0] == 'd') // "delete" 5557 { 5558 // When no match was found we don't need to remember the 5559 // buffer, wipe it out. If there was a match and it 5560 // wasn't the first one or we won't jump there: only 5561 // unload the buffer. 5562 // Ignore 'hidden' here, because it may lead to having too 5563 // many swap files. 5564 if (!found_match) 5565 { 5566 wipe_dummy_buffer(buf, dirname_start); 5567 buf = NULL; 5568 } 5569 else if (buf != first_match_buf || (flags & VGR_NOJUMP)) 5570 { 5571 unload_dummy_buffer(buf, dirname_start); 5572 // Keeping the buffer, remove the dummy flag. 5573 buf->b_flags &= ~BF_DUMMY; 5574 buf = NULL; 5575 } 5576 } 5577 5578 if (buf != NULL) 5579 { 5580 // Keeping the buffer, remove the dummy flag. 5581 buf->b_flags &= ~BF_DUMMY; 5582 5583 // If the buffer is still loaded we need to use the 5584 // directory we jumped to below. 5585 if (buf == first_match_buf 5586 && target_dir == NULL 5587 && STRCMP(dirname_start, dirname_now) != 0) 5588 target_dir = vim_strsave(dirname_now); 5589 5590 // The buffer is still loaded, the Filetype autocommands 5591 // need to be done now, in that buffer. And the modelines 5592 // need to be done (again). But not the window-local 5593 // options! 5594 aucmd_prepbuf(&aco, buf); 5595 #if defined(FEAT_SYN_HL) 5596 apply_autocmds(EVENT_FILETYPE, buf->b_p_ft, 5597 buf->b_fname, TRUE, buf); 5598 #endif 5599 do_modelines(OPT_NOWIN); 5600 aucmd_restbuf(&aco); 5601 } 5602 } 5603 } 5604 } 5605 5606 FreeWild(fcount, fnames); 5607 5608 qfl = qf_get_curlist(qi); 5609 qfl->qf_nonevalid = FALSE; 5610 qfl->qf_ptr = qfl->qf_start; 5611 qfl->qf_index = 1; 5612 qf_list_changed(qfl); 5613 5614 qf_update_buffer(qi, NULL); 5615 5616 if (au_name != NULL) 5617 apply_autocmds(EVENT_QUICKFIXCMDPOST, au_name, 5618 curbuf->b_fname, TRUE, curbuf); 5619 // The QuickFixCmdPost autocmd may free the quickfix list. Check the list 5620 // is still valid. 5621 if (!qflist_valid(wp, save_qfid) 5622 || qf_restore_list(qi, save_qfid) == FAIL) 5623 { 5624 decr_quickfix_busy(); 5625 goto theend; 5626 } 5627 5628 // Jump to first match. 5629 if (!qf_list_empty(qf_get_curlist(qi))) 5630 { 5631 if ((flags & VGR_NOJUMP) == 0) 5632 vgr_jump_to_match(qi, eap->forceit, &redraw_for_dummy, 5633 first_match_buf, target_dir); 5634 } 5635 else 5636 semsg(_(e_nomatch2), s); 5637 5638 decr_quickfix_busy(); 5639 5640 // If we loaded a dummy buffer into the current window, the autocommands 5641 // may have messed up things, need to redraw and recompute folds. 5642 if (redraw_for_dummy) 5643 { 5644 #ifdef FEAT_FOLDING 5645 foldUpdateAll(curwin); 5646 #else 5647 redraw_later(NOT_VALID); 5648 #endif 5649 } 5650 5651 theend: 5652 vim_free(title); 5653 vim_free(dirname_now); 5654 vim_free(dirname_start); 5655 vim_free(target_dir); 5656 vim_regfree(regmatch.regprog); 5657 } 5658 5659 /* 5660 * Restore current working directory to "dirname_start" if they differ, taking 5661 * into account whether it is set locally or globally. 5662 */ 5663 static void 5664 restore_start_dir(char_u *dirname_start) 5665 { 5666 char_u *dirname_now = alloc(MAXPATHL); 5667 5668 if (NULL != dirname_now) 5669 { 5670 mch_dirname(dirname_now, MAXPATHL); 5671 if (STRCMP(dirname_start, dirname_now) != 0) 5672 { 5673 // If the directory has changed, change it back by building up an 5674 // appropriate ex command and executing it. 5675 exarg_T ea; 5676 5677 ea.arg = dirname_start; 5678 ea.cmdidx = (curwin->w_localdir == NULL) ? CMD_cd : CMD_lcd; 5679 ex_cd(&ea); 5680 } 5681 vim_free(dirname_now); 5682 } 5683 } 5684 5685 /* 5686 * Load file "fname" into a dummy buffer and return the buffer pointer, 5687 * placing the directory resulting from the buffer load into the 5688 * "resulting_dir" pointer. "resulting_dir" must be allocated by the caller 5689 * prior to calling this function. Restores directory to "dirname_start" prior 5690 * to returning, if autocmds or the 'autochdir' option have changed it. 5691 * 5692 * If creating the dummy buffer does not fail, must call unload_dummy_buffer() 5693 * or wipe_dummy_buffer() later! 5694 * 5695 * Returns NULL if it fails. 5696 */ 5697 static buf_T * 5698 load_dummy_buffer( 5699 char_u *fname, 5700 char_u *dirname_start, // in: old directory 5701 char_u *resulting_dir) // out: new directory 5702 { 5703 buf_T *newbuf; 5704 bufref_T newbufref; 5705 bufref_T newbuf_to_wipe; 5706 int failed = TRUE; 5707 aco_save_T aco; 5708 int readfile_result; 5709 5710 // Allocate a buffer without putting it in the buffer list. 5711 newbuf = buflist_new(NULL, NULL, (linenr_T)1, BLN_DUMMY); 5712 if (newbuf == NULL) 5713 return NULL; 5714 set_bufref(&newbufref, newbuf); 5715 5716 // Init the options. 5717 buf_copy_options(newbuf, BCO_ENTER | BCO_NOHELP); 5718 5719 // need to open the memfile before putting the buffer in a window 5720 if (ml_open(newbuf) == OK) 5721 { 5722 // Make sure this buffer isn't wiped out by autocommands. 5723 ++newbuf->b_locked; 5724 5725 // set curwin/curbuf to buf and save a few things 5726 aucmd_prepbuf(&aco, newbuf); 5727 5728 // Need to set the filename for autocommands. 5729 (void)setfname(curbuf, fname, NULL, FALSE); 5730 5731 // Create swap file now to avoid the ATTENTION message. 5732 check_need_swap(TRUE); 5733 5734 // Remove the "dummy" flag, otherwise autocommands may not 5735 // work. 5736 curbuf->b_flags &= ~BF_DUMMY; 5737 5738 newbuf_to_wipe.br_buf = NULL; 5739 readfile_result = readfile(fname, NULL, 5740 (linenr_T)0, (linenr_T)0, (linenr_T)MAXLNUM, 5741 NULL, READ_NEW | READ_DUMMY); 5742 --newbuf->b_locked; 5743 if (readfile_result == OK 5744 && !got_int 5745 && !(curbuf->b_flags & BF_NEW)) 5746 { 5747 failed = FALSE; 5748 if (curbuf != newbuf) 5749 { 5750 // Bloody autocommands changed the buffer! Can happen when 5751 // using netrw and editing a remote file. Use the current 5752 // buffer instead, delete the dummy one after restoring the 5753 // window stuff. 5754 set_bufref(&newbuf_to_wipe, newbuf); 5755 newbuf = curbuf; 5756 } 5757 } 5758 5759 // restore curwin/curbuf and a few other things 5760 aucmd_restbuf(&aco); 5761 if (newbuf_to_wipe.br_buf != NULL && bufref_valid(&newbuf_to_wipe)) 5762 wipe_buffer(newbuf_to_wipe.br_buf, FALSE); 5763 5764 // Add back the "dummy" flag, otherwise buflist_findname_stat() won't 5765 // skip it. 5766 newbuf->b_flags |= BF_DUMMY; 5767 } 5768 5769 // When autocommands/'autochdir' option changed directory: go back. 5770 // Let the caller know what the resulting dir was first, in case it is 5771 // important. 5772 mch_dirname(resulting_dir, MAXPATHL); 5773 restore_start_dir(dirname_start); 5774 5775 if (!bufref_valid(&newbufref)) 5776 return NULL; 5777 if (failed) 5778 { 5779 wipe_dummy_buffer(newbuf, dirname_start); 5780 return NULL; 5781 } 5782 return newbuf; 5783 } 5784 5785 /* 5786 * Wipe out the dummy buffer that load_dummy_buffer() created. Restores 5787 * directory to "dirname_start" prior to returning, if autocmds or the 5788 * 'autochdir' option have changed it. 5789 */ 5790 static void 5791 wipe_dummy_buffer(buf_T *buf, char_u *dirname_start) 5792 { 5793 if (curbuf != buf) // safety check 5794 { 5795 #if defined(FEAT_EVAL) 5796 cleanup_T cs; 5797 5798 // Reset the error/interrupt/exception state here so that aborting() 5799 // returns FALSE when wiping out the buffer. Otherwise it doesn't 5800 // work when got_int is set. 5801 enter_cleanup(&cs); 5802 #endif 5803 5804 wipe_buffer(buf, FALSE); 5805 5806 #if defined(FEAT_EVAL) 5807 // Restore the error/interrupt/exception state if not discarded by a 5808 // new aborting error, interrupt, or uncaught exception. 5809 leave_cleanup(&cs); 5810 #endif 5811 // When autocommands/'autochdir' option changed directory: go back. 5812 restore_start_dir(dirname_start); 5813 } 5814 } 5815 5816 /* 5817 * Unload the dummy buffer that load_dummy_buffer() created. Restores 5818 * directory to "dirname_start" prior to returning, if autocmds or the 5819 * 'autochdir' option have changed it. 5820 */ 5821 static void 5822 unload_dummy_buffer(buf_T *buf, char_u *dirname_start) 5823 { 5824 if (curbuf != buf) // safety check 5825 { 5826 close_buffer(NULL, buf, DOBUF_UNLOAD, FALSE); 5827 5828 // When autocommands/'autochdir' option changed directory: go back. 5829 restore_start_dir(dirname_start); 5830 } 5831 } 5832 5833 #if defined(FEAT_EVAL) || defined(PROTO) 5834 /* 5835 * Add each quickfix error to list "list" as a dictionary. 5836 * If qf_idx is -1, use the current list. Otherwise, use the specified list. 5837 */ 5838 int 5839 get_errorlist(qf_info_T *qi_arg, win_T *wp, int qf_idx, list_T *list) 5840 { 5841 qf_info_T *qi = qi_arg; 5842 qf_list_T *qfl; 5843 dict_T *dict; 5844 char_u buf[2]; 5845 qfline_T *qfp; 5846 int i; 5847 int bufnum; 5848 5849 if (qi == NULL) 5850 { 5851 qi = &ql_info; 5852 if (wp != NULL) 5853 { 5854 qi = GET_LOC_LIST(wp); 5855 if (qi == NULL) 5856 return FAIL; 5857 } 5858 } 5859 5860 if (qf_idx == INVALID_QFIDX) 5861 qf_idx = qi->qf_curlist; 5862 5863 if (qf_idx >= qi->qf_listcount) 5864 return FAIL; 5865 5866 qfl = qf_get_list(qi, qf_idx); 5867 if (qf_list_empty(qfl)) 5868 return FAIL; 5869 5870 qfp = qfl->qf_start; 5871 for (i = 1; !got_int && i <= qfl->qf_count; ++i) 5872 { 5873 // Handle entries with a non-existing buffer number. 5874 bufnum = qfp->qf_fnum; 5875 if (bufnum != 0 && (buflist_findnr(bufnum) == NULL)) 5876 bufnum = 0; 5877 5878 if ((dict = dict_alloc()) == NULL) 5879 return FAIL; 5880 if (list_append_dict(list, dict) == FAIL) 5881 return FAIL; 5882 5883 buf[0] = qfp->qf_type; 5884 buf[1] = NUL; 5885 if ( dict_add_number(dict, "bufnr", (long)bufnum) == FAIL 5886 || dict_add_number(dict, "lnum", (long)qfp->qf_lnum) == FAIL 5887 || dict_add_number(dict, "col", (long)qfp->qf_col) == FAIL 5888 || dict_add_number(dict, "vcol", (long)qfp->qf_viscol) == FAIL 5889 || dict_add_number(dict, "nr", (long)qfp->qf_nr) == FAIL 5890 || dict_add_string(dict, "module", qfp->qf_module) == FAIL 5891 || dict_add_string(dict, "pattern", qfp->qf_pattern) == FAIL 5892 || dict_add_string(dict, "text", qfp->qf_text) == FAIL 5893 || dict_add_string(dict, "type", buf) == FAIL 5894 || dict_add_number(dict, "valid", (long)qfp->qf_valid) == FAIL) 5895 return FAIL; 5896 5897 qfp = qfp->qf_next; 5898 if (qfp == NULL) 5899 break; 5900 } 5901 return OK; 5902 } 5903 5904 // Flags used by getqflist()/getloclist() to determine which fields to return. 5905 enum { 5906 QF_GETLIST_NONE = 0x0, 5907 QF_GETLIST_TITLE = 0x1, 5908 QF_GETLIST_ITEMS = 0x2, 5909 QF_GETLIST_NR = 0x4, 5910 QF_GETLIST_WINID = 0x8, 5911 QF_GETLIST_CONTEXT = 0x10, 5912 QF_GETLIST_ID = 0x20, 5913 QF_GETLIST_IDX = 0x40, 5914 QF_GETLIST_SIZE = 0x80, 5915 QF_GETLIST_TICK = 0x100, 5916 QF_GETLIST_FILEWINID = 0x200, 5917 QF_GETLIST_QFBUFNR = 0x400, 5918 QF_GETLIST_ALL = 0x7FF, 5919 }; 5920 5921 /* 5922 * Parse text from 'di' and return the quickfix list items. 5923 * Existing quickfix lists are not modified. 5924 */ 5925 static int 5926 qf_get_list_from_lines(dict_T *what, dictitem_T *di, dict_T *retdict) 5927 { 5928 int status = FAIL; 5929 qf_info_T *qi; 5930 char_u *errorformat = p_efm; 5931 dictitem_T *efm_di; 5932 list_T *l; 5933 5934 // Only a List value is supported 5935 if (di->di_tv.v_type == VAR_LIST && di->di_tv.vval.v_list != NULL) 5936 { 5937 // If errorformat is supplied then use it, otherwise use the 'efm' 5938 // option setting 5939 if ((efm_di = dict_find(what, (char_u *)"efm", -1)) != NULL) 5940 { 5941 if (efm_di->di_tv.v_type != VAR_STRING || 5942 efm_di->di_tv.vval.v_string == NULL) 5943 return FAIL; 5944 errorformat = efm_di->di_tv.vval.v_string; 5945 } 5946 5947 l = list_alloc(); 5948 if (l == NULL) 5949 return FAIL; 5950 5951 qi = qf_alloc_stack(QFLT_INTERNAL); 5952 if (qi != NULL) 5953 { 5954 if (qf_init_ext(qi, 0, NULL, NULL, &di->di_tv, errorformat, 5955 TRUE, (linenr_T)0, (linenr_T)0, NULL, NULL) > 0) 5956 { 5957 (void)get_errorlist(qi, NULL, 0, l); 5958 qf_free(&qi->qf_lists[0]); 5959 } 5960 free(qi); 5961 } 5962 dict_add_list(retdict, "items", l); 5963 status = OK; 5964 } 5965 5966 return status; 5967 } 5968 5969 /* 5970 * Return the quickfix/location list window identifier in the current tabpage. 5971 */ 5972 static int 5973 qf_winid(qf_info_T *qi) 5974 { 5975 win_T *win; 5976 5977 // The quickfix window can be opened even if the quickfix list is not set 5978 // using ":copen". This is not true for location lists. 5979 if (qi == NULL) 5980 return 0; 5981 win = qf_find_win(qi); 5982 if (win != NULL) 5983 return win->w_id; 5984 return 0; 5985 } 5986 5987 /* 5988 * Returns the number of the buffer displayed in the quickfix/location list 5989 * window. If there is no buffer associated with the list, then returns 0. 5990 */ 5991 static int 5992 qf_getprop_qfbufnr(qf_info_T *qi, dict_T *retdict) 5993 { 5994 return dict_add_number(retdict, "qfbufnr", 5995 (qi == NULL) ? 0 : qi->qf_bufnr); 5996 } 5997 5998 /* 5999 * Convert the keys in 'what' to quickfix list property flags. 6000 */ 6001 static int 6002 qf_getprop_keys2flags(dict_T *what, int loclist) 6003 { 6004 int flags = QF_GETLIST_NONE; 6005 6006 if (dict_find(what, (char_u *)"all", -1) != NULL) 6007 { 6008 flags |= QF_GETLIST_ALL; 6009 if (!loclist) 6010 // File window ID is applicable only to location list windows 6011 flags &= ~ QF_GETLIST_FILEWINID; 6012 } 6013 6014 if (dict_find(what, (char_u *)"title", -1) != NULL) 6015 flags |= QF_GETLIST_TITLE; 6016 6017 if (dict_find(what, (char_u *)"nr", -1) != NULL) 6018 flags |= QF_GETLIST_NR; 6019 6020 if (dict_find(what, (char_u *)"winid", -1) != NULL) 6021 flags |= QF_GETLIST_WINID; 6022 6023 if (dict_find(what, (char_u *)"context", -1) != NULL) 6024 flags |= QF_GETLIST_CONTEXT; 6025 6026 if (dict_find(what, (char_u *)"id", -1) != NULL) 6027 flags |= QF_GETLIST_ID; 6028 6029 if (dict_find(what, (char_u *)"items", -1) != NULL) 6030 flags |= QF_GETLIST_ITEMS; 6031 6032 if (dict_find(what, (char_u *)"idx", -1) != NULL) 6033 flags |= QF_GETLIST_IDX; 6034 6035 if (dict_find(what, (char_u *)"size", -1) != NULL) 6036 flags |= QF_GETLIST_SIZE; 6037 6038 if (dict_find(what, (char_u *)"changedtick", -1) != NULL) 6039 flags |= QF_GETLIST_TICK; 6040 6041 if (loclist && dict_find(what, (char_u *)"filewinid", -1) != NULL) 6042 flags |= QF_GETLIST_FILEWINID; 6043 6044 if (dict_find(what, (char_u *)"qfbufnr", -1) != NULL) 6045 flags |= QF_GETLIST_QFBUFNR; 6046 6047 return flags; 6048 } 6049 6050 /* 6051 * Return the quickfix list index based on 'nr' or 'id' in 'what'. 6052 * If 'nr' and 'id' are not present in 'what' then return the current 6053 * quickfix list index. 6054 * If 'nr' is zero then return the current quickfix list index. 6055 * If 'nr' is '$' then return the last quickfix list index. 6056 * If 'id' is present then return the index of the quickfix list with that id. 6057 * If 'id' is zero then return the quickfix list index specified by 'nr'. 6058 * Return -1, if quickfix list is not present or if the stack is empty. 6059 */ 6060 static int 6061 qf_getprop_qfidx(qf_info_T *qi, dict_T *what) 6062 { 6063 int qf_idx; 6064 dictitem_T *di; 6065 6066 qf_idx = qi->qf_curlist; // default is the current list 6067 if ((di = dict_find(what, (char_u *)"nr", -1)) != NULL) 6068 { 6069 // Use the specified quickfix/location list 6070 if (di->di_tv.v_type == VAR_NUMBER) 6071 { 6072 // for zero use the current list 6073 if (di->di_tv.vval.v_number != 0) 6074 { 6075 qf_idx = di->di_tv.vval.v_number - 1; 6076 if (qf_idx < 0 || qf_idx >= qi->qf_listcount) 6077 qf_idx = INVALID_QFIDX; 6078 } 6079 } 6080 else if (di->di_tv.v_type == VAR_STRING 6081 && di->di_tv.vval.v_string != NULL 6082 && STRCMP(di->di_tv.vval.v_string, "$") == 0) 6083 // Get the last quickfix list number 6084 qf_idx = qi->qf_listcount - 1; 6085 else 6086 qf_idx = INVALID_QFIDX; 6087 } 6088 6089 if ((di = dict_find(what, (char_u *)"id", -1)) != NULL) 6090 { 6091 // Look for a list with the specified id 6092 if (di->di_tv.v_type == VAR_NUMBER) 6093 { 6094 // For zero, use the current list or the list specified by 'nr' 6095 if (di->di_tv.vval.v_number != 0) 6096 qf_idx = qf_id2nr(qi, di->di_tv.vval.v_number); 6097 } 6098 else 6099 qf_idx = INVALID_QFIDX; 6100 } 6101 6102 return qf_idx; 6103 } 6104 6105 /* 6106 * Return default values for quickfix list properties in retdict. 6107 */ 6108 static int 6109 qf_getprop_defaults(qf_info_T *qi, int flags, int locstack, dict_T *retdict) 6110 { 6111 int status = OK; 6112 6113 if (flags & QF_GETLIST_TITLE) 6114 status = dict_add_string(retdict, "title", (char_u *)""); 6115 if ((status == OK) && (flags & QF_GETLIST_ITEMS)) 6116 { 6117 list_T *l = list_alloc(); 6118 if (l != NULL) 6119 status = dict_add_list(retdict, "items", l); 6120 else 6121 status = FAIL; 6122 } 6123 if ((status == OK) && (flags & QF_GETLIST_NR)) 6124 status = dict_add_number(retdict, "nr", 0); 6125 if ((status == OK) && (flags & QF_GETLIST_WINID)) 6126 status = dict_add_number(retdict, "winid", qf_winid(qi)); 6127 if ((status == OK) && (flags & QF_GETLIST_CONTEXT)) 6128 status = dict_add_string(retdict, "context", (char_u *)""); 6129 if ((status == OK) && (flags & QF_GETLIST_ID)) 6130 status = dict_add_number(retdict, "id", 0); 6131 if ((status == OK) && (flags & QF_GETLIST_IDX)) 6132 status = dict_add_number(retdict, "idx", 0); 6133 if ((status == OK) && (flags & QF_GETLIST_SIZE)) 6134 status = dict_add_number(retdict, "size", 0); 6135 if ((status == OK) && (flags & QF_GETLIST_TICK)) 6136 status = dict_add_number(retdict, "changedtick", 0); 6137 if ((status == OK) && locstack && (flags & QF_GETLIST_FILEWINID)) 6138 status = dict_add_number(retdict, "filewinid", 0); 6139 if ((status == OK) && (flags & QF_GETLIST_QFBUFNR)) 6140 status = qf_getprop_qfbufnr(qi, retdict); 6141 6142 return status; 6143 } 6144 6145 /* 6146 * Return the quickfix list title as 'title' in retdict 6147 */ 6148 static int 6149 qf_getprop_title(qf_list_T *qfl, dict_T *retdict) 6150 { 6151 return dict_add_string(retdict, "title", qfl->qf_title); 6152 } 6153 6154 /* 6155 * Returns the identifier of the window used to display files from a location 6156 * list. If there is no associated window, then returns 0. Useful only when 6157 * called from a location list window. 6158 */ 6159 static int 6160 qf_getprop_filewinid(win_T *wp, qf_info_T *qi, dict_T *retdict) 6161 { 6162 int winid = 0; 6163 6164 if (wp != NULL && IS_LL_WINDOW(wp)) 6165 { 6166 win_T *ll_wp = qf_find_win_with_loclist(qi); 6167 if (ll_wp != NULL) 6168 winid = ll_wp->w_id; 6169 } 6170 6171 return dict_add_number(retdict, "filewinid", winid); 6172 } 6173 6174 /* 6175 * Return the quickfix list items/entries as 'items' in retdict 6176 */ 6177 static int 6178 qf_getprop_items(qf_info_T *qi, int qf_idx, dict_T *retdict) 6179 { 6180 int status = OK; 6181 list_T *l = list_alloc(); 6182 if (l != NULL) 6183 { 6184 (void)get_errorlist(qi, NULL, qf_idx, l); 6185 dict_add_list(retdict, "items", l); 6186 } 6187 else 6188 status = FAIL; 6189 6190 return status; 6191 } 6192 6193 /* 6194 * Return the quickfix list context (if any) as 'context' in retdict. 6195 */ 6196 static int 6197 qf_getprop_ctx(qf_list_T *qfl, dict_T *retdict) 6198 { 6199 int status; 6200 dictitem_T *di; 6201 6202 if (qfl->qf_ctx != NULL) 6203 { 6204 di = dictitem_alloc((char_u *)"context"); 6205 if (di != NULL) 6206 { 6207 copy_tv(qfl->qf_ctx, &di->di_tv); 6208 status = dict_add(retdict, di); 6209 if (status == FAIL) 6210 dictitem_free(di); 6211 } 6212 else 6213 status = FAIL; 6214 } 6215 else 6216 status = dict_add_string(retdict, "context", (char_u *)""); 6217 6218 return status; 6219 } 6220 6221 /* 6222 * Return the current quickfix list index as 'idx' in retdict 6223 */ 6224 static int 6225 qf_getprop_idx(qf_list_T *qfl, dict_T *retdict) 6226 { 6227 int curidx = qfl->qf_index; 6228 if (qf_list_empty(qfl)) 6229 // For empty lists, current index is set to 0 6230 curidx = 0; 6231 return dict_add_number(retdict, "idx", curidx); 6232 } 6233 6234 /* 6235 * Return quickfix/location list details (title) as a 6236 * dictionary. 'what' contains the details to return. If 'list_idx' is -1, 6237 * then current list is used. Otherwise the specified list is used. 6238 */ 6239 int 6240 qf_get_properties(win_T *wp, dict_T *what, dict_T *retdict) 6241 { 6242 qf_info_T *qi = &ql_info; 6243 qf_list_T *qfl; 6244 int status = OK; 6245 int qf_idx = INVALID_QFIDX; 6246 dictitem_T *di; 6247 int flags = QF_GETLIST_NONE; 6248 6249 if ((di = dict_find(what, (char_u *)"lines", -1)) != NULL) 6250 return qf_get_list_from_lines(what, di, retdict); 6251 6252 if (wp != NULL) 6253 qi = GET_LOC_LIST(wp); 6254 6255 flags = qf_getprop_keys2flags(what, (wp != NULL)); 6256 6257 if (!qf_stack_empty(qi)) 6258 qf_idx = qf_getprop_qfidx(qi, what); 6259 6260 // List is not present or is empty 6261 if (qf_stack_empty(qi) || qf_idx == INVALID_QFIDX) 6262 return qf_getprop_defaults(qi, flags, wp != NULL, retdict); 6263 6264 qfl = qf_get_list(qi, qf_idx); 6265 6266 if (flags & QF_GETLIST_TITLE) 6267 status = qf_getprop_title(qfl, retdict); 6268 if ((status == OK) && (flags & QF_GETLIST_NR)) 6269 status = dict_add_number(retdict, "nr", qf_idx + 1); 6270 if ((status == OK) && (flags & QF_GETLIST_WINID)) 6271 status = dict_add_number(retdict, "winid", qf_winid(qi)); 6272 if ((status == OK) && (flags & QF_GETLIST_ITEMS)) 6273 status = qf_getprop_items(qi, qf_idx, retdict); 6274 if ((status == OK) && (flags & QF_GETLIST_CONTEXT)) 6275 status = qf_getprop_ctx(qfl, retdict); 6276 if ((status == OK) && (flags & QF_GETLIST_ID)) 6277 status = dict_add_number(retdict, "id", qfl->qf_id); 6278 if ((status == OK) && (flags & QF_GETLIST_IDX)) 6279 status = qf_getprop_idx(qfl, retdict); 6280 if ((status == OK) && (flags & QF_GETLIST_SIZE)) 6281 status = dict_add_number(retdict, "size", qfl->qf_count); 6282 if ((status == OK) && (flags & QF_GETLIST_TICK)) 6283 status = dict_add_number(retdict, "changedtick", qfl->qf_changedtick); 6284 if ((status == OK) && (wp != NULL) && (flags & QF_GETLIST_FILEWINID)) 6285 status = qf_getprop_filewinid(wp, qi, retdict); 6286 if ((status == OK) && (flags & QF_GETLIST_QFBUFNR)) 6287 status = qf_getprop_qfbufnr(qi, retdict); 6288 6289 return status; 6290 } 6291 6292 /* 6293 * Add a new quickfix entry to list at 'qf_idx' in the stack 'qi' from the 6294 * items in the dict 'd'. If it is a valid error entry, then set 'valid_entry' 6295 * to TRUE. 6296 */ 6297 static int 6298 qf_add_entry_from_dict( 6299 qf_list_T *qfl, 6300 dict_T *d, 6301 int first_entry, 6302 int *valid_entry) 6303 { 6304 static int did_bufnr_emsg; 6305 char_u *filename, *module, *pattern, *text, *type; 6306 int bufnum, valid, status, col, vcol, nr; 6307 long lnum; 6308 6309 if (first_entry) 6310 did_bufnr_emsg = FALSE; 6311 6312 filename = dict_get_string(d, (char_u *)"filename", TRUE); 6313 module = dict_get_string(d, (char_u *)"module", TRUE); 6314 bufnum = (int)dict_get_number(d, (char_u *)"bufnr"); 6315 lnum = (int)dict_get_number(d, (char_u *)"lnum"); 6316 col = (int)dict_get_number(d, (char_u *)"col"); 6317 vcol = (int)dict_get_number(d, (char_u *)"vcol"); 6318 nr = (int)dict_get_number(d, (char_u *)"nr"); 6319 type = dict_get_string(d, (char_u *)"type", TRUE); 6320 pattern = dict_get_string(d, (char_u *)"pattern", TRUE); 6321 text = dict_get_string(d, (char_u *)"text", TRUE); 6322 if (text == NULL) 6323 text = vim_strsave((char_u *)""); 6324 6325 valid = TRUE; 6326 if ((filename == NULL && bufnum == 0) || (lnum == 0 && pattern == NULL)) 6327 valid = FALSE; 6328 6329 // Mark entries with non-existing buffer number as not valid. Give the 6330 // error message only once. 6331 if (bufnum != 0 && (buflist_findnr(bufnum) == NULL)) 6332 { 6333 if (!did_bufnr_emsg) 6334 { 6335 did_bufnr_emsg = TRUE; 6336 semsg(_("E92: Buffer %d not found"), bufnum); 6337 } 6338 valid = FALSE; 6339 bufnum = 0; 6340 } 6341 6342 // If the 'valid' field is present it overrules the detected value. 6343 if ((dict_find(d, (char_u *)"valid", -1)) != NULL) 6344 valid = (int)dict_get_number(d, (char_u *)"valid"); 6345 6346 status = qf_add_entry(qfl, 6347 NULL, // dir 6348 filename, 6349 module, 6350 bufnum, 6351 text, 6352 lnum, 6353 col, 6354 vcol, // vis_col 6355 pattern, // search pattern 6356 nr, 6357 type == NULL ? NUL : *type, 6358 valid); 6359 6360 vim_free(filename); 6361 vim_free(module); 6362 vim_free(pattern); 6363 vim_free(text); 6364 vim_free(type); 6365 6366 if (valid) 6367 *valid_entry = TRUE; 6368 6369 return status; 6370 } 6371 6372 /* 6373 * Add list of entries to quickfix/location list. Each list entry is 6374 * a dictionary with item information. 6375 */ 6376 static int 6377 qf_add_entries( 6378 qf_info_T *qi, 6379 int qf_idx, 6380 list_T *list, 6381 char_u *title, 6382 int action) 6383 { 6384 qf_list_T *qfl = qf_get_list(qi, qf_idx); 6385 listitem_T *li; 6386 dict_T *d; 6387 qfline_T *old_last = NULL; 6388 int retval = OK; 6389 int valid_entry = FALSE; 6390 6391 if (action == ' ' || qf_idx == qi->qf_listcount) 6392 { 6393 // make place for a new list 6394 qf_new_list(qi, title); 6395 qf_idx = qi->qf_curlist; 6396 qfl = qf_get_list(qi, qf_idx); 6397 } 6398 else if (action == 'a' && !qf_list_empty(qfl)) 6399 // Adding to existing list, use last entry. 6400 old_last = qfl->qf_last; 6401 else if (action == 'r') 6402 { 6403 qf_free_items(qfl); 6404 qf_store_title(qfl, title); 6405 } 6406 6407 for (li = list->lv_first; li != NULL; li = li->li_next) 6408 { 6409 if (li->li_tv.v_type != VAR_DICT) 6410 continue; // Skip non-dict items 6411 6412 d = li->li_tv.vval.v_dict; 6413 if (d == NULL) 6414 continue; 6415 6416 retval = qf_add_entry_from_dict(qfl, d, li == list->lv_first, 6417 &valid_entry); 6418 if (retval == FAIL) 6419 break; 6420 } 6421 6422 // Check if any valid error entries are added to the list. 6423 if (valid_entry) 6424 qfl->qf_nonevalid = FALSE; 6425 else if (qfl->qf_index == 0) 6426 // no valid entry 6427 qfl->qf_nonevalid = TRUE; 6428 6429 // If not appending to the list, set the current error to the first entry 6430 if (action != 'a') 6431 qfl->qf_ptr = qfl->qf_start; 6432 6433 // Update the current error index if not appending to the list or if the 6434 // list was empty before and it is not empty now. 6435 if ((action != 'a' || qfl->qf_index == 0) && !qf_list_empty(qfl)) 6436 qfl->qf_index = 1; 6437 6438 // Don't update the cursor in quickfix window when appending entries 6439 qf_update_buffer(qi, old_last); 6440 6441 return retval; 6442 } 6443 6444 /* 6445 * Get the quickfix list index from 'nr' or 'id' 6446 */ 6447 static int 6448 qf_setprop_get_qfidx( 6449 qf_info_T *qi, 6450 dict_T *what, 6451 int action, 6452 int *newlist) 6453 { 6454 dictitem_T *di; 6455 int qf_idx = qi->qf_curlist; // default is the current list 6456 6457 if ((di = dict_find(what, (char_u *)"nr", -1)) != NULL) 6458 { 6459 // Use the specified quickfix/location list 6460 if (di->di_tv.v_type == VAR_NUMBER) 6461 { 6462 // for zero use the current list 6463 if (di->di_tv.vval.v_number != 0) 6464 qf_idx = di->di_tv.vval.v_number - 1; 6465 6466 if ((action == ' ' || action == 'a') && qf_idx == qi->qf_listcount) 6467 { 6468 // When creating a new list, accept qf_idx pointing to the next 6469 // non-available list and add the new list at the end of the 6470 // stack. 6471 *newlist = TRUE; 6472 qf_idx = qf_stack_empty(qi) ? 0 : qi->qf_listcount - 1; 6473 } 6474 else if (qf_idx < 0 || qf_idx >= qi->qf_listcount) 6475 return INVALID_QFIDX; 6476 else if (action != ' ') 6477 *newlist = FALSE; // use the specified list 6478 } 6479 else if (di->di_tv.v_type == VAR_STRING 6480 && di->di_tv.vval.v_string != NULL 6481 && STRCMP(di->di_tv.vval.v_string, "$") == 0) 6482 { 6483 if (!qf_stack_empty(qi)) 6484 qf_idx = qi->qf_listcount - 1; 6485 else if (*newlist) 6486 qf_idx = 0; 6487 else 6488 return INVALID_QFIDX; 6489 } 6490 else 6491 return INVALID_QFIDX; 6492 } 6493 6494 if (!*newlist && (di = dict_find(what, (char_u *)"id", -1)) != NULL) 6495 { 6496 // Use the quickfix/location list with the specified id 6497 if (di->di_tv.v_type != VAR_NUMBER) 6498 return INVALID_QFIDX; 6499 6500 return qf_id2nr(qi, di->di_tv.vval.v_number); 6501 } 6502 6503 return qf_idx; 6504 } 6505 6506 /* 6507 * Set the quickfix list title. 6508 */ 6509 static int 6510 qf_setprop_title(qf_info_T *qi, int qf_idx, dict_T *what, dictitem_T *di) 6511 { 6512 qf_list_T *qfl = qf_get_list(qi, qf_idx); 6513 6514 if (di->di_tv.v_type != VAR_STRING) 6515 return FAIL; 6516 6517 vim_free(qfl->qf_title); 6518 qfl->qf_title = dict_get_string(what, (char_u *)"title", TRUE); 6519 if (qf_idx == qi->qf_curlist) 6520 qf_update_win_titlevar(qi); 6521 6522 return OK; 6523 } 6524 6525 /* 6526 * Set quickfix list items/entries. 6527 */ 6528 static int 6529 qf_setprop_items(qf_info_T *qi, int qf_idx, dictitem_T *di, int action) 6530 { 6531 int retval = FAIL; 6532 char_u *title_save; 6533 6534 if (di->di_tv.v_type != VAR_LIST) 6535 return FAIL; 6536 6537 title_save = vim_strsave(qi->qf_lists[qf_idx].qf_title); 6538 retval = qf_add_entries(qi, qf_idx, di->di_tv.vval.v_list, 6539 title_save, action == ' ' ? 'a' : action); 6540 vim_free(title_save); 6541 6542 return retval; 6543 } 6544 6545 /* 6546 * Set quickfix list items/entries from a list of lines. 6547 */ 6548 static int 6549 qf_setprop_items_from_lines( 6550 qf_info_T *qi, 6551 int qf_idx, 6552 dict_T *what, 6553 dictitem_T *di, 6554 int action) 6555 { 6556 char_u *errorformat = p_efm; 6557 dictitem_T *efm_di; 6558 int retval = FAIL; 6559 6560 // Use the user supplied errorformat settings (if present) 6561 if ((efm_di = dict_find(what, (char_u *)"efm", -1)) != NULL) 6562 { 6563 if (efm_di->di_tv.v_type != VAR_STRING || 6564 efm_di->di_tv.vval.v_string == NULL) 6565 return FAIL; 6566 errorformat = efm_di->di_tv.vval.v_string; 6567 } 6568 6569 // Only a List value is supported 6570 if (di->di_tv.v_type != VAR_LIST || di->di_tv.vval.v_list == NULL) 6571 return FAIL; 6572 6573 if (action == 'r') 6574 qf_free_items(&qi->qf_lists[qf_idx]); 6575 if (qf_init_ext(qi, qf_idx, NULL, NULL, &di->di_tv, errorformat, 6576 FALSE, (linenr_T)0, (linenr_T)0, NULL, NULL) > 0) 6577 retval = OK; 6578 6579 return retval; 6580 } 6581 6582 /* 6583 * Set quickfix list context. 6584 */ 6585 static int 6586 qf_setprop_context(qf_list_T *qfl, dictitem_T *di) 6587 { 6588 typval_T *ctx; 6589 6590 free_tv(qfl->qf_ctx); 6591 ctx = alloc_tv(); 6592 if (ctx != NULL) 6593 copy_tv(&di->di_tv, ctx); 6594 qfl->qf_ctx = ctx; 6595 6596 return OK; 6597 } 6598 6599 /* 6600 * Set the current index in the specified quickfix list 6601 */ 6602 static int 6603 qf_setprop_curidx(qf_info_T *qi, qf_list_T *qfl, dictitem_T *di) 6604 { 6605 int denote = FALSE; 6606 int newidx; 6607 int old_qfidx; 6608 qfline_T *qf_ptr; 6609 6610 // If the specified index is '$', then use the last entry 6611 if (di->di_tv.v_type == VAR_STRING 6612 && di->di_tv.vval.v_string != NULL 6613 && STRCMP(di->di_tv.vval.v_string, "$") == 0) 6614 newidx = qfl->qf_count; 6615 else 6616 { 6617 // Otherwise use the specified index 6618 newidx = tv_get_number_chk(&di->di_tv, &denote); 6619 if (denote) 6620 return FAIL; 6621 } 6622 6623 if (newidx < 1) // sanity check 6624 return FAIL; 6625 if (newidx > qfl->qf_count) 6626 newidx = qfl->qf_count; 6627 6628 old_qfidx = qfl->qf_index; 6629 qf_ptr = get_nth_entry(qfl, newidx, &newidx); 6630 if (qf_ptr == NULL) 6631 return FAIL; 6632 qfl->qf_ptr = qf_ptr; 6633 qfl->qf_index = newidx; 6634 6635 // If the current list is modified and it is displayed in the quickfix 6636 // window, then Update it. 6637 if (qf_get_curlist(qi)->qf_id == qfl->qf_id) 6638 qf_win_pos_update(qi, old_qfidx); 6639 6640 return OK; 6641 } 6642 6643 /* 6644 * Set quickfix/location list properties (title, items, context). 6645 * Also used to add items from parsing a list of lines. 6646 * Used by the setqflist() and setloclist() Vim script functions. 6647 */ 6648 static int 6649 qf_set_properties(qf_info_T *qi, dict_T *what, int action, char_u *title) 6650 { 6651 dictitem_T *di; 6652 int retval = FAIL; 6653 int qf_idx; 6654 int newlist = FALSE; 6655 qf_list_T *qfl; 6656 6657 if (action == ' ' || qf_stack_empty(qi)) 6658 newlist = TRUE; 6659 6660 qf_idx = qf_setprop_get_qfidx(qi, what, action, &newlist); 6661 if (qf_idx == INVALID_QFIDX) // List not found 6662 return FAIL; 6663 6664 if (newlist) 6665 { 6666 qi->qf_curlist = qf_idx; 6667 qf_new_list(qi, title); 6668 qf_idx = qi->qf_curlist; 6669 } 6670 6671 qfl = qf_get_list(qi, qf_idx); 6672 if ((di = dict_find(what, (char_u *)"title", -1)) != NULL) 6673 retval = qf_setprop_title(qi, qf_idx, what, di); 6674 if ((di = dict_find(what, (char_u *)"items", -1)) != NULL) 6675 retval = qf_setprop_items(qi, qf_idx, di, action); 6676 if ((di = dict_find(what, (char_u *)"lines", -1)) != NULL) 6677 retval = qf_setprop_items_from_lines(qi, qf_idx, what, di, action); 6678 if ((di = dict_find(what, (char_u *)"context", -1)) != NULL) 6679 retval = qf_setprop_context(qfl, di); 6680 if ((di = dict_find(what, (char_u *)"idx", -1)) != NULL) 6681 retval = qf_setprop_curidx(qi, qfl, di); 6682 6683 if (retval == OK) 6684 qf_list_changed(qfl); 6685 6686 return retval; 6687 } 6688 6689 /* 6690 * Free the entire quickfix/location list stack. 6691 * If the quickfix/location list window is open, then clear it. 6692 */ 6693 static void 6694 qf_free_stack(win_T *wp, qf_info_T *qi) 6695 { 6696 win_T *qfwin = qf_find_win(qi); 6697 win_T *llwin = NULL; 6698 6699 if (qfwin != NULL) 6700 { 6701 // If the quickfix/location list window is open, then clear it 6702 if (qi->qf_curlist < qi->qf_listcount) 6703 qf_free(qf_get_curlist(qi)); 6704 qf_update_buffer(qi, NULL); 6705 } 6706 6707 if (wp != NULL && IS_LL_WINDOW(wp)) 6708 { 6709 // If in the location list window, then use the non-location list 6710 // window with this location list (if present) 6711 llwin = qf_find_win_with_loclist(qi); 6712 if (llwin != NULL) 6713 wp = llwin; 6714 } 6715 6716 qf_free_all(wp); 6717 if (wp == NULL) 6718 { 6719 // quickfix list 6720 qi->qf_curlist = 0; 6721 qi->qf_listcount = 0; 6722 } 6723 else if (qfwin != NULL) 6724 { 6725 // If the location list window is open, then create a new empty 6726 // location list 6727 qf_info_T *new_ll = qf_alloc_stack(QFLT_LOCATION); 6728 new_ll->qf_bufnr = qfwin->w_buffer->b_fnum; 6729 6730 // first free the list reference in the location list window 6731 ll_free_all(&qfwin->w_llist_ref); 6732 6733 qfwin->w_llist_ref = new_ll; 6734 if (wp != qfwin) 6735 win_set_loclist(wp, new_ll); 6736 } 6737 } 6738 6739 /* 6740 * Populate the quickfix list with the items supplied in the list 6741 * of dictionaries. "title" will be copied to w:quickfix_title. 6742 * "action" is 'a' for add, 'r' for replace. Otherwise create a new list. 6743 */ 6744 int 6745 set_errorlist( 6746 win_T *wp, 6747 list_T *list, 6748 int action, 6749 char_u *title, 6750 dict_T *what) 6751 { 6752 qf_info_T *qi = &ql_info; 6753 int retval = OK; 6754 6755 if (wp != NULL) 6756 { 6757 qi = ll_get_or_alloc_list(wp); 6758 if (qi == NULL) 6759 return FAIL; 6760 } 6761 6762 if (action == 'f') 6763 { 6764 // Free the entire quickfix or location list stack 6765 qf_free_stack(wp, qi); 6766 return OK; 6767 } 6768 6769 incr_quickfix_busy(); 6770 6771 if (what != NULL) 6772 retval = qf_set_properties(qi, what, action, title); 6773 else 6774 { 6775 retval = qf_add_entries(qi, qi->qf_curlist, list, title, action); 6776 if (retval == OK) 6777 qf_list_changed(qf_get_curlist(qi)); 6778 } 6779 6780 decr_quickfix_busy(); 6781 6782 return retval; 6783 } 6784 6785 /* 6786 * Mark the context as in use for all the lists in a quickfix stack. 6787 */ 6788 static int 6789 mark_quickfix_ctx(qf_info_T *qi, int copyID) 6790 { 6791 int i; 6792 int abort = FALSE; 6793 typval_T *ctx; 6794 6795 for (i = 0; i < LISTCOUNT && !abort; ++i) 6796 { 6797 ctx = qi->qf_lists[i].qf_ctx; 6798 if (ctx != NULL && ctx->v_type != VAR_NUMBER 6799 && ctx->v_type != VAR_STRING && ctx->v_type != VAR_FLOAT) 6800 abort = set_ref_in_item(ctx, copyID, NULL, NULL); 6801 } 6802 6803 return abort; 6804 } 6805 6806 /* 6807 * Mark the context of the quickfix list and the location lists (if present) as 6808 * "in use". So that garbage collection doesn't free the context. 6809 */ 6810 int 6811 set_ref_in_quickfix(int copyID) 6812 { 6813 int abort = FALSE; 6814 tabpage_T *tp; 6815 win_T *win; 6816 6817 abort = mark_quickfix_ctx(&ql_info, copyID); 6818 if (abort) 6819 return abort; 6820 6821 FOR_ALL_TAB_WINDOWS(tp, win) 6822 { 6823 if (win->w_llist != NULL) 6824 { 6825 abort = mark_quickfix_ctx(win->w_llist, copyID); 6826 if (abort) 6827 return abort; 6828 } 6829 if (IS_LL_WINDOW(win) && (win->w_llist_ref->qf_refcount == 1)) 6830 { 6831 // In a location list window and none of the other windows is 6832 // referring to this location list. Mark the location list 6833 // context as still in use. 6834 abort = mark_quickfix_ctx(win->w_llist_ref, copyID); 6835 if (abort) 6836 return abort; 6837 } 6838 } 6839 6840 return abort; 6841 } 6842 #endif 6843 6844 /* 6845 * ":[range]cbuffer [bufnr]" command. 6846 * ":[range]caddbuffer [bufnr]" command. 6847 * ":[range]cgetbuffer [bufnr]" command. 6848 * ":[range]lbuffer [bufnr]" command. 6849 * ":[range]laddbuffer [bufnr]" command. 6850 * ":[range]lgetbuffer [bufnr]" command. 6851 */ 6852 void 6853 ex_cbuffer(exarg_T *eap) 6854 { 6855 buf_T *buf = NULL; 6856 qf_info_T *qi = &ql_info; 6857 char_u *au_name = NULL; 6858 int res; 6859 int_u save_qfid; 6860 win_T *wp = NULL; 6861 6862 switch (eap->cmdidx) 6863 { 6864 case CMD_cbuffer: au_name = (char_u *)"cbuffer"; break; 6865 case CMD_cgetbuffer: au_name = (char_u *)"cgetbuffer"; break; 6866 case CMD_caddbuffer: au_name = (char_u *)"caddbuffer"; break; 6867 case CMD_lbuffer: au_name = (char_u *)"lbuffer"; break; 6868 case CMD_lgetbuffer: au_name = (char_u *)"lgetbuffer"; break; 6869 case CMD_laddbuffer: au_name = (char_u *)"laddbuffer"; break; 6870 default: break; 6871 } 6872 if (au_name != NULL && apply_autocmds(EVENT_QUICKFIXCMDPRE, au_name, 6873 curbuf->b_fname, TRUE, curbuf)) 6874 { 6875 #ifdef FEAT_EVAL 6876 if (aborting()) 6877 return; 6878 #endif 6879 } 6880 6881 // Must come after autocommands. 6882 if (is_loclist_cmd(eap->cmdidx)) 6883 { 6884 qi = ll_get_or_alloc_list(curwin); 6885 if (qi == NULL) 6886 return; 6887 wp = curwin; 6888 } 6889 6890 if (*eap->arg == NUL) 6891 buf = curbuf; 6892 else if (*skipwhite(skipdigits(eap->arg)) == NUL) 6893 buf = buflist_findnr(atoi((char *)eap->arg)); 6894 if (buf == NULL) 6895 emsg(_(e_invarg)); 6896 else if (buf->b_ml.ml_mfp == NULL) 6897 emsg(_("E681: Buffer is not loaded")); 6898 else 6899 { 6900 if (eap->addr_count == 0) 6901 { 6902 eap->line1 = 1; 6903 eap->line2 = buf->b_ml.ml_line_count; 6904 } 6905 if (eap->line1 < 1 || eap->line1 > buf->b_ml.ml_line_count 6906 || eap->line2 < 1 || eap->line2 > buf->b_ml.ml_line_count) 6907 emsg(_(e_invrange)); 6908 else 6909 { 6910 char_u *qf_title = qf_cmdtitle(*eap->cmdlinep); 6911 6912 if (buf->b_sfname) 6913 { 6914 vim_snprintf((char *)IObuff, IOSIZE, "%s (%s)", 6915 (char *)qf_title, (char *)buf->b_sfname); 6916 qf_title = IObuff; 6917 } 6918 6919 incr_quickfix_busy(); 6920 6921 res = qf_init_ext(qi, qi->qf_curlist, NULL, buf, NULL, p_efm, 6922 (eap->cmdidx != CMD_caddbuffer 6923 && eap->cmdidx != CMD_laddbuffer), 6924 eap->line1, eap->line2, 6925 qf_title, NULL); 6926 if (qf_stack_empty(qi)) 6927 { 6928 decr_quickfix_busy(); 6929 return; 6930 } 6931 if (res >= 0) 6932 qf_list_changed(qf_get_curlist(qi)); 6933 6934 // Remember the current quickfix list identifier, so that we can 6935 // check for autocommands changing the current quickfix list. 6936 save_qfid = qf_get_curlist(qi)->qf_id; 6937 if (au_name != NULL) 6938 { 6939 buf_T *curbuf_old = curbuf; 6940 6941 apply_autocmds(EVENT_QUICKFIXCMDPOST, au_name, 6942 curbuf->b_fname, TRUE, curbuf); 6943 if (curbuf != curbuf_old) 6944 // Autocommands changed buffer, don't jump now, "qi" may 6945 // be invalid. 6946 res = 0; 6947 } 6948 // Jump to the first error for a new list and if autocmds didn't 6949 // free the list. 6950 if (res > 0 && (eap->cmdidx == CMD_cbuffer || 6951 eap->cmdidx == CMD_lbuffer) 6952 && qflist_valid(wp, save_qfid)) 6953 // display the first error 6954 qf_jump_first(qi, save_qfid, eap->forceit); 6955 6956 decr_quickfix_busy(); 6957 } 6958 } 6959 } 6960 6961 #if defined(FEAT_EVAL) || defined(PROTO) 6962 /* 6963 * ":cexpr {expr}", ":cgetexpr {expr}", ":caddexpr {expr}" command. 6964 * ":lexpr {expr}", ":lgetexpr {expr}", ":laddexpr {expr}" command. 6965 */ 6966 void 6967 ex_cexpr(exarg_T *eap) 6968 { 6969 typval_T *tv; 6970 qf_info_T *qi = &ql_info; 6971 char_u *au_name = NULL; 6972 int res; 6973 int_u save_qfid; 6974 win_T *wp = NULL; 6975 6976 switch (eap->cmdidx) 6977 { 6978 case CMD_cexpr: au_name = (char_u *)"cexpr"; break; 6979 case CMD_cgetexpr: au_name = (char_u *)"cgetexpr"; break; 6980 case CMD_caddexpr: au_name = (char_u *)"caddexpr"; break; 6981 case CMD_lexpr: au_name = (char_u *)"lexpr"; break; 6982 case CMD_lgetexpr: au_name = (char_u *)"lgetexpr"; break; 6983 case CMD_laddexpr: au_name = (char_u *)"laddexpr"; break; 6984 default: break; 6985 } 6986 if (au_name != NULL && apply_autocmds(EVENT_QUICKFIXCMDPRE, au_name, 6987 curbuf->b_fname, TRUE, curbuf)) 6988 { 6989 #ifdef FEAT_EVAL 6990 if (aborting()) 6991 return; 6992 #endif 6993 } 6994 6995 if (is_loclist_cmd(eap->cmdidx)) 6996 { 6997 qi = ll_get_or_alloc_list(curwin); 6998 if (qi == NULL) 6999 return; 7000 wp = curwin; 7001 } 7002 7003 // Evaluate the expression. When the result is a string or a list we can 7004 // use it to fill the errorlist. 7005 tv = eval_expr(eap->arg, NULL); 7006 if (tv != NULL) 7007 { 7008 if ((tv->v_type == VAR_STRING && tv->vval.v_string != NULL) 7009 || (tv->v_type == VAR_LIST && tv->vval.v_list != NULL)) 7010 { 7011 incr_quickfix_busy(); 7012 res = qf_init_ext(qi, qi->qf_curlist, NULL, NULL, tv, p_efm, 7013 (eap->cmdidx != CMD_caddexpr 7014 && eap->cmdidx != CMD_laddexpr), 7015 (linenr_T)0, (linenr_T)0, 7016 qf_cmdtitle(*eap->cmdlinep), NULL); 7017 if (qf_stack_empty(qi)) 7018 { 7019 decr_quickfix_busy(); 7020 goto cleanup; 7021 } 7022 if (res >= 0) 7023 qf_list_changed(qf_get_curlist(qi)); 7024 7025 // Remember the current quickfix list identifier, so that we can 7026 // check for autocommands changing the current quickfix list. 7027 save_qfid = qf_get_curlist(qi)->qf_id; 7028 if (au_name != NULL) 7029 apply_autocmds(EVENT_QUICKFIXCMDPOST, au_name, 7030 curbuf->b_fname, TRUE, curbuf); 7031 7032 // Jump to the first error for a new list and if autocmds didn't 7033 // free the list. 7034 if (res > 0 && (eap->cmdidx == CMD_cexpr 7035 || eap->cmdidx == CMD_lexpr) 7036 && qflist_valid(wp, save_qfid)) 7037 // display the first error 7038 qf_jump_first(qi, save_qfid, eap->forceit); 7039 decr_quickfix_busy(); 7040 } 7041 else 7042 emsg(_("E777: String or List expected")); 7043 cleanup: 7044 free_tv(tv); 7045 } 7046 } 7047 #endif 7048 7049 /* 7050 * Get the location list for ":lhelpgrep" 7051 */ 7052 static qf_info_T * 7053 hgr_get_ll(int *new_ll) 7054 { 7055 win_T *wp; 7056 qf_info_T *qi; 7057 7058 // If the current window is a help window, then use it 7059 if (bt_help(curwin->w_buffer)) 7060 wp = curwin; 7061 else 7062 // Find an existing help window 7063 wp = qf_find_help_win(); 7064 7065 if (wp == NULL) // Help window not found 7066 qi = NULL; 7067 else 7068 qi = wp->w_llist; 7069 7070 if (qi == NULL) 7071 { 7072 // Allocate a new location list for help text matches 7073 if ((qi = qf_alloc_stack(QFLT_LOCATION)) == NULL) 7074 return NULL; 7075 *new_ll = TRUE; 7076 } 7077 7078 return qi; 7079 } 7080 7081 /* 7082 * Search for a pattern in a help file. 7083 */ 7084 static void 7085 hgr_search_file( 7086 qf_list_T *qfl, 7087 char_u *fname, 7088 vimconv_T *p_vc, 7089 regmatch_T *p_regmatch) 7090 { 7091 FILE *fd; 7092 long lnum; 7093 7094 fd = mch_fopen((char *)fname, "r"); 7095 if (fd == NULL) 7096 return; 7097 7098 lnum = 1; 7099 while (!vim_fgets(IObuff, IOSIZE, fd) && !got_int) 7100 { 7101 char_u *line = IObuff; 7102 7103 // Convert a line if 'encoding' is not utf-8 and 7104 // the line contains a non-ASCII character. 7105 if (p_vc->vc_type != CONV_NONE 7106 && has_non_ascii(IObuff)) 7107 { 7108 line = string_convert(p_vc, IObuff, NULL); 7109 if (line == NULL) 7110 line = IObuff; 7111 } 7112 7113 if (vim_regexec(p_regmatch, line, (colnr_T)0)) 7114 { 7115 int l = (int)STRLEN(line); 7116 7117 // remove trailing CR, LF, spaces, etc. 7118 while (l > 0 && line[l - 1] <= ' ') 7119 line[--l] = NUL; 7120 7121 if (qf_add_entry(qfl, 7122 NULL, // dir 7123 fname, 7124 NULL, 7125 0, 7126 line, 7127 lnum, 7128 (int)(p_regmatch->startp[0] - line) 7129 + 1, // col 7130 FALSE, // vis_col 7131 NULL, // search pattern 7132 0, // nr 7133 1, // type 7134 TRUE // valid 7135 ) == FAIL) 7136 { 7137 got_int = TRUE; 7138 if (line != IObuff) 7139 vim_free(line); 7140 break; 7141 } 7142 } 7143 if (line != IObuff) 7144 vim_free(line); 7145 ++lnum; 7146 line_breakcheck(); 7147 } 7148 fclose(fd); 7149 } 7150 7151 /* 7152 * Search for a pattern in all the help files in the doc directory under 7153 * the given directory. 7154 */ 7155 static void 7156 hgr_search_files_in_dir( 7157 qf_list_T *qfl, 7158 char_u *dirname, 7159 regmatch_T *p_regmatch, 7160 vimconv_T *p_vc 7161 #ifdef FEAT_MULTI_LANG 7162 , char_u *lang 7163 #endif 7164 ) 7165 { 7166 int fcount; 7167 char_u **fnames; 7168 int fi; 7169 7170 // Find all "*.txt" and "*.??x" files in the "doc" directory. 7171 add_pathsep(dirname); 7172 STRCAT(dirname, "doc/*.\\(txt\\|??x\\)"); 7173 if (gen_expand_wildcards(1, &dirname, &fcount, 7174 &fnames, EW_FILE|EW_SILENT) == OK 7175 && fcount > 0) 7176 { 7177 for (fi = 0; fi < fcount && !got_int; ++fi) 7178 { 7179 #ifdef FEAT_MULTI_LANG 7180 // Skip files for a different language. 7181 if (lang != NULL 7182 && STRNICMP(lang, fnames[fi] 7183 + STRLEN(fnames[fi]) - 3, 2) != 0 7184 && !(STRNICMP(lang, "en", 2) == 0 7185 && STRNICMP("txt", fnames[fi] 7186 + STRLEN(fnames[fi]) - 3, 3) == 0)) 7187 continue; 7188 #endif 7189 7190 hgr_search_file(qfl, fnames[fi], p_vc, p_regmatch); 7191 } 7192 FreeWild(fcount, fnames); 7193 } 7194 } 7195 7196 /* 7197 * Search for a pattern in all the help files in the 'runtimepath' 7198 * and add the matches to a quickfix list. 7199 * 'lang' is the language specifier. If supplied, then only matches in the 7200 * specified language are found. 7201 */ 7202 static void 7203 hgr_search_in_rtp(qf_list_T *qfl, regmatch_T *p_regmatch, char_u *lang) 7204 { 7205 char_u *p; 7206 7207 vimconv_T vc; 7208 7209 // Help files are in utf-8 or latin1, convert lines when 'encoding' 7210 // differs. 7211 vc.vc_type = CONV_NONE; 7212 if (!enc_utf8) 7213 convert_setup(&vc, (char_u *)"utf-8", p_enc); 7214 7215 // Go through all the directories in 'runtimepath' 7216 p = p_rtp; 7217 while (*p != NUL && !got_int) 7218 { 7219 copy_option_part(&p, NameBuff, MAXPATHL, ","); 7220 7221 hgr_search_files_in_dir(qfl, NameBuff, p_regmatch, &vc 7222 #ifdef FEAT_MULTI_LANG 7223 , lang 7224 #endif 7225 ); 7226 } 7227 7228 if (vc.vc_type != CONV_NONE) 7229 convert_setup(&vc, NULL, NULL); 7230 } 7231 7232 /* 7233 * ":helpgrep {pattern}" 7234 */ 7235 void 7236 ex_helpgrep(exarg_T *eap) 7237 { 7238 regmatch_T regmatch; 7239 char_u *save_cpo; 7240 qf_info_T *qi = &ql_info; 7241 int new_qi = FALSE; 7242 char_u *au_name = NULL; 7243 char_u *lang = NULL; 7244 7245 switch (eap->cmdidx) 7246 { 7247 case CMD_helpgrep: au_name = (char_u *)"helpgrep"; break; 7248 case CMD_lhelpgrep: au_name = (char_u *)"lhelpgrep"; break; 7249 default: break; 7250 } 7251 if (au_name != NULL && apply_autocmds(EVENT_QUICKFIXCMDPRE, au_name, 7252 curbuf->b_fname, TRUE, curbuf)) 7253 { 7254 #ifdef FEAT_EVAL 7255 if (aborting()) 7256 return; 7257 #endif 7258 } 7259 7260 // Make 'cpoptions' empty, the 'l' flag should not be used here. 7261 save_cpo = p_cpo; 7262 p_cpo = empty_option; 7263 7264 if (is_loclist_cmd(eap->cmdidx)) 7265 { 7266 qi = hgr_get_ll(&new_qi); 7267 if (qi == NULL) 7268 return; 7269 } 7270 7271 incr_quickfix_busy(); 7272 7273 #ifdef FEAT_MULTI_LANG 7274 // Check for a specified language 7275 lang = check_help_lang(eap->arg); 7276 #endif 7277 regmatch.regprog = vim_regcomp(eap->arg, RE_MAGIC + RE_STRING); 7278 regmatch.rm_ic = FALSE; 7279 if (regmatch.regprog != NULL) 7280 { 7281 qf_list_T *qfl; 7282 7283 // create a new quickfix list 7284 qf_new_list(qi, qf_cmdtitle(*eap->cmdlinep)); 7285 qfl = qf_get_curlist(qi); 7286 7287 hgr_search_in_rtp(qfl, ®match, lang); 7288 7289 vim_regfree(regmatch.regprog); 7290 7291 qfl->qf_nonevalid = FALSE; 7292 qfl->qf_ptr = qfl->qf_start; 7293 qfl->qf_index = 1; 7294 qf_list_changed(qfl); 7295 qf_update_buffer(qi, NULL); 7296 } 7297 7298 if (p_cpo == empty_option) 7299 p_cpo = save_cpo; 7300 else 7301 // Darn, some plugin changed the value. 7302 free_string_option(save_cpo); 7303 7304 if (au_name != NULL) 7305 { 7306 apply_autocmds(EVENT_QUICKFIXCMDPOST, au_name, 7307 curbuf->b_fname, TRUE, curbuf); 7308 if (!new_qi && IS_LL_STACK(qi) && qf_find_buf(qi) == NULL) 7309 { 7310 // autocommands made "qi" invalid 7311 decr_quickfix_busy(); 7312 return; 7313 } 7314 } 7315 7316 // Jump to first match. 7317 if (!qf_list_empty(qf_get_curlist(qi))) 7318 qf_jump(qi, 0, 0, FALSE); 7319 else 7320 semsg(_(e_nomatch2), eap->arg); 7321 7322 decr_quickfix_busy(); 7323 7324 if (eap->cmdidx == CMD_lhelpgrep) 7325 { 7326 // If the help window is not opened or if it already points to the 7327 // correct location list, then free the new location list. 7328 if (!bt_help(curwin->w_buffer) || curwin->w_llist == qi) 7329 { 7330 if (new_qi) 7331 ll_free_all(&qi); 7332 } 7333 else if (curwin->w_llist == NULL) 7334 curwin->w_llist = qi; 7335 } 7336 } 7337 7338 #endif /* FEAT_QUICKFIX */ 7339