![[BACK]](/icons/back.gif){kind=icon}
Return to quickfix.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / vim|
Return to quickfix.c CVS log | Up to [local] / src / usr.bin / vim |
1.1 ! downsj 1: /* $OpenBSD$ */
! 2: /* vi:set ts=4 sw=4:
! 3: *
! 4: * VIM - Vi IMproved by Bram Moolenaar
! 5: *
! 6: * Do ":help uganda" in Vim to read copying and usage conditions.
! 7: * Do ":help credits" in Vim to see a list of people who contributed.
! 8: */
! 9:
! 10: /*
! 11: * quickfix.c: functions for quickfix mode, using a file with error messages
! 12: */
! 13:
! 14: #include "vim.h"
! 15: #include "globals.h"
! 16: #include "proto.h"
! 17: #include "option.h"
! 18:
! 19: static void qf_free __ARGS((void));
! 20: static char_u *qf_types __ARGS((int, int));
! 21:
! 22: /*
! 23: * for each error the next struct is allocated and linked in a list
! 24: */
! 25: struct qf_line
! 26: {
! 27: struct qf_line *qf_next; /* pointer to next error in the list */
! 28: struct qf_line *qf_prev; /* pointer to previous error in the list */
! 29: linenr_t qf_lnum; /* line number where the error occurred */
! 30: int qf_fnum; /* file number for the line */
! 31: int qf_col; /* column where the error occurred */
! 32: int qf_nr; /* error number */
! 33: char_u *qf_text; /* description of the error */
! 34: char_u qf_cleared;/* set to TRUE if line has been deleted */
! 35: char_u qf_type; /* type of the error (mostly 'E') */
! 36: char_u qf_valid; /* valid error message detected */
! 37: };
! 38:
! 39: static struct qf_line *qf_start; /* pointer to the first error */
! 40: static struct qf_line *qf_ptr; /* pointer to the current error */
! 41:
! 42: static int qf_count = 0; /* number of errors (0 means no error list) */
! 43: static int qf_index; /* current index in the error list */
! 44: static int qf_nonevalid; /* set to TRUE if not a single valid entry found */
! 45:
! 46: #define MAX_ADDR 7 /* maximum number of % recognized, also adjust
! 47: sscanf() below */
! 48:
! 49: /*
! 50: * Structure used to hold the info of one part of 'errorformat'
! 51: */
! 52: struct eformat
! 53: {
! 54: char_u *fmtstr; /* pre-formatted part of 'errorformat' */
! 55: #ifdef UTS2
! 56: char_u *(adr[MAX_ADDR]); /* addresses used */
! 57: #else
! 58: void *(adr[MAX_ADDR]);
! 59: #endif
! 60: int adr_cnt; /* number of addresses used */
! 61: struct eformat *next; /* pointer to next (NULL if last) */
! 62: };
! 63:
! 64: /*
! 65: * Read the errorfile into memory, line by line, building the error list.
! 66: * Return FAIL for error, OK for success.
! 67: */
! 68: int
! 69: qf_init()
! 70: {
! 71: char_u *namebuf;
! 72: char_u *errmsg;
! 73: int col;
! 74: int type;
! 75: int valid;
! 76: long lnum;
! 77: int enr;
! 78: FILE *fd;
! 79: struct qf_line *qfp = NULL;
! 80: struct qf_line *qfprev = NULL; /* init to make SASC shut up */
! 81: char_u *efmp;
! 82: struct eformat *fmt_first = NULL;
! 83: struct eformat *fmt_last = NULL;
! 84: struct eformat *fmt_ptr;
! 85: char_u *efm;
! 86: int maxlen;
! 87: int len;
! 88: int i, j;
! 89: int retval = FAIL;
! 90:
! 91: if (*p_ef == NUL)
! 92: {
! 93: emsg(e_errorf);
! 94: return FAIL;
! 95: }
! 96:
! 97: namebuf = alloc(CMDBUFFSIZE + 1);
! 98: errmsg = alloc(CMDBUFFSIZE + 1);
! 99: if (namebuf == NULL || errmsg == NULL)
! 100: goto qf_init_end;
! 101:
! 102: if ((fd = fopen((char *)p_ef, "r")) == NULL)
! 103: {
! 104: emsg2(e_openerrf, p_ef);
! 105: goto qf_init_end;
! 106: }
! 107: qf_free();
! 108: qf_index = 0;
! 109:
! 110: /*
! 111: * Each part of the format string is copied and modified from p_efm to fmtstr.
! 112: * Only a few % characters are allowed.
! 113: */
! 114: efm = p_efm;
! 115: while (efm[0])
! 116: {
! 117: /*
! 118: * Allocate a new eformat structure and put it at the end of the list
! 119: */
! 120: fmt_ptr = (struct eformat *)alloc((unsigned)sizeof(struct eformat));
! 121: if (fmt_ptr == NULL)
! 122: goto error2;
! 123: if (fmt_first == NULL) /* first one */
! 124: fmt_first = fmt_ptr;
! 125: else
! 126: fmt_last->next = fmt_ptr;
! 127: fmt_last = fmt_ptr;
! 128: fmt_ptr->next = NULL;
! 129: fmt_ptr->adr_cnt = 0;
! 130:
! 131: /*
! 132: * Isolate one part in the 'errorformat' option
! 133: */
! 134: for (len = 0; efm[len] != NUL && efm[len] != ','; ++len)
! 135: if (efm[len] == '\\' && efm[len + 1] != NUL)
! 136: ++len;
! 137:
! 138: /*
! 139: * Get some space to modify the format string into.
! 140: * Must be able to do the largest expansion (x3) MAX_ADDR times.
! 141: */
! 142: maxlen = len + MAX_ADDR * 3 + 4;
! 143: if ((fmt_ptr->fmtstr = alloc(maxlen)) == NULL)
! 144: goto error2;
! 145:
! 146: for (i = 0; i < MAX_ADDR; ++i)
! 147: fmt_ptr->adr[i] = NULL;
! 148:
! 149: for (efmp = efm, i = 0; efmp < efm + len; ++efmp, ++i)
! 150: {
! 151: if (efmp[0] != '%') /* copy normal character */
! 152: {
! 153: if (efmp[0] == '\\' && efmp + 1 < efm + len)
! 154: ++efmp;
! 155: fmt_ptr->fmtstr[i] = efmp[0];
! 156: }
! 157: else
! 158: {
! 159: fmt_ptr->fmtstr[i++] = '%';
! 160: switch (efmp[1])
! 161: {
! 162: case 'f': /* filename */
! 163: fmt_ptr->adr[fmt_ptr->adr_cnt++] = namebuf;
! 164: /* FALLTHROUGH */
! 165:
! 166: case 'm': /* message */
! 167: if (efmp[1] == 'm')
! 168: fmt_ptr->adr[fmt_ptr->adr_cnt++] = errmsg;
! 169: fmt_ptr->fmtstr[i++] = '[';
! 170: fmt_ptr->fmtstr[i++] = '^';
! 171: #ifdef __EMX__
! 172: /* don't allow spaces in filename. This fixes
! 173: * the broken sscanf() where an empty message
! 174: * is accepted as a valid conversion.
! 175: */
! 176: if (efmp[1] == 'f')
! 177: fmt_ptr->fmtstr[i++] = ' ';
! 178: #endif
! 179: if (efmp[2] == '\\') /* could be "%m\," */
! 180: j = 3;
! 181: else
! 182: j = 2;
! 183: if (efmp + j < efm + len)
! 184: fmt_ptr->fmtstr[i++] = efmp[j];
! 185: else
! 186: {
! 187: /*
! 188: * The %f or %m is the last one in the format,
! 189: * stop at the CR of NL at the end of the line.
! 190: */
! 191: #ifdef USE_CRNL
! 192: fmt_ptr->fmtstr[i++] = '\r';
! 193: #endif
! 194: fmt_ptr->fmtstr[i++] = '\n';
! 195: }
! 196: fmt_ptr->fmtstr[i] = ']';
! 197: break;
! 198: case 'c': /* column */
! 199: fmt_ptr->adr[fmt_ptr->adr_cnt++] = &col;
! 200: fmt_ptr->fmtstr[i] = 'd';
! 201: break;
! 202: case 'l': /* line */
! 203: fmt_ptr->adr[fmt_ptr->adr_cnt++] = &lnum;
! 204: fmt_ptr->fmtstr[i++] = 'l';
! 205: fmt_ptr->fmtstr[i] = 'd';
! 206: break;
! 207: case 'n': /* error number */
! 208: fmt_ptr->adr[fmt_ptr->adr_cnt++] = &enr;
! 209: fmt_ptr->fmtstr[i] = 'd';
! 210: break;
! 211: case 't': /* error type */
! 212: fmt_ptr->adr[fmt_ptr->adr_cnt++] = &type;
! 213: fmt_ptr->fmtstr[i] = 'c';
! 214: break;
! 215: case '%': /* %% */
! 216: case '*': /* %*: no assignment */
! 217: fmt_ptr->fmtstr[i] = efmp[1];
! 218: break;
! 219: default:
! 220: EMSG("invalid % in format string");
! 221: goto error2;
! 222: }
! 223: if (fmt_ptr->adr_cnt == MAX_ADDR)
! 224: {
! 225: EMSG("too many % in format string");
! 226: goto error2;
! 227: }
! 228: ++efmp;
! 229: }
! 230: if (i >= maxlen - 6)
! 231: {
! 232: EMSG("invalid format string");
! 233: goto error2;
! 234: }
! 235: }
! 236: fmt_ptr->fmtstr[i] = NUL;
! 237:
! 238: /*
! 239: * Advance to next part
! 240: */
! 241: efm = skip_to_option_part(efm + len); /* skip comma and spaces */
! 242: }
! 243: if (fmt_first == NULL) /* nothing found */
! 244: {
! 245: EMSG("'errorformat' contains no pattern");
! 246: goto error2;
! 247: }
! 248:
! 249: /*
! 250: * Read the lines in the error file one by one.
! 251: * Try to recognize one of the error formats in each line.
! 252: */
! 253: while (fgets((char *)IObuff, CMDBUFFSIZE, fd) != NULL && !got_int)
! 254: {
! 255: if ((qfp = (struct qf_line *)alloc((unsigned)sizeof(struct qf_line)))
! 256: == NULL)
! 257: goto error2;
! 258:
! 259: IObuff[CMDBUFFSIZE] = NUL; /* for very long lines */
! 260:
! 261: /*
! 262: * Try to match each part of 'errorformat' until we find a complete
! 263: * match or none matches.
! 264: */
! 265: valid = TRUE;
! 266: for (fmt_ptr = fmt_first; fmt_ptr != NULL; fmt_ptr = fmt_ptr->next)
! 267: {
! 268: namebuf[0] = NUL;
! 269: errmsg[0] = NUL;
! 270: lnum = 0;
! 271: col = 0;
! 272: enr = -1;
! 273: type = 0;
! 274:
! 275: /*
! 276: * If first char of the format and message don't match, there is
! 277: * no need to try sscanf() on it... Somehow I believe there are
! 278: * very slow implementations of sscanf().
! 279: * -- Paul Slootman
! 280: */
! 281: if (fmt_ptr->fmtstr[0] != '%' && fmt_ptr->fmtstr[0] != IObuff[0])
! 282: continue;
! 283:
! 284: if (sscanf((char *)IObuff, (char *)fmt_ptr->fmtstr,
! 285: fmt_ptr->adr[0], fmt_ptr->adr[1], fmt_ptr->adr[2],
! 286: fmt_ptr->adr[3], fmt_ptr->adr[4], fmt_ptr->adr[5],
! 287: fmt_ptr->adr[6]) == fmt_ptr->adr_cnt)
! 288: break;
! 289: }
! 290: if (fmt_ptr == NULL)
! 291: {
! 292: namebuf[0] = NUL; /* no match found, remove file name */
! 293: lnum = 0; /* don't jump to this line */
! 294: valid = FALSE;
! 295: STRCPY(errmsg, IObuff); /* copy whole line to error message */
! 296: if ((efmp = vim_strrchr(errmsg, '\n')) != NULL)
! 297: *efmp = NUL;
! 298: #ifdef USE_CRNL
! 299: if ((efmp = vim_strrchr(errmsg, '\r')) != NULL)
! 300: *efmp = NUL;
! 301: #endif
! 302: }
! 303:
! 304: if (namebuf[0] == NUL) /* no file name */
! 305: qfp->qf_fnum = 0;
! 306: else
! 307: qfp->qf_fnum = buflist_add(namebuf);
! 308: if ((qfp->qf_text = strsave(errmsg)) == NULL)
! 309: goto error1;
! 310: qfp->qf_lnum = lnum;
! 311: qfp->qf_col = col;
! 312: qfp->qf_nr = enr;
! 313: qfp->qf_type = type;
! 314: qfp->qf_valid = valid;
! 315:
! 316: if (qf_count == 0) /* first element in the list */
! 317: {
! 318: qf_start = qfp;
! 319: qfp->qf_prev = qfp; /* first element points to itself */
! 320: }
! 321: else
! 322: {
! 323: qfp->qf_prev = qfprev;
! 324: qfprev->qf_next = qfp;
! 325: }
! 326: qfp->qf_next = qfp; /* last element points to itself */
! 327: qfp->qf_cleared = FALSE;
! 328: qfprev = qfp;
! 329: ++qf_count;
! 330: if (qf_index == 0 && qfp->qf_valid) /* first valid entry */
! 331: {
! 332: qf_index = qf_count;
! 333: qf_ptr = qfp;
! 334: }
! 335: line_breakcheck();
! 336: }
! 337: if (!ferror(fd))
! 338: {
! 339: if (qf_index == 0) /* no valid entry found */
! 340: {
! 341: qf_ptr = qf_start;
! 342: qf_index = 1;
! 343: qf_nonevalid = TRUE;
! 344: }
! 345: else
! 346: qf_nonevalid = FALSE;
! 347: retval = OK;
! 348: goto qf_init_ok;
! 349: }
! 350: emsg(e_readerrf);
! 351: error1:
! 352: vim_free(qfp);
! 353: error2:
! 354: qf_free();
! 355: qf_init_ok:
! 356: fclose(fd);
! 357: for (fmt_ptr = fmt_first; fmt_ptr != NULL; fmt_ptr = fmt_first)
! 358: {
! 359: fmt_first = fmt_ptr->next;
! 360: vim_free(fmt_ptr->fmtstr);
! 361: vim_free(fmt_ptr);
! 362: }
! 363: qf_init_end:
! 364: vim_free(namebuf);
! 365: vim_free(errmsg);
! 366: return retval;
! 367: }
! 368:
! 369: /*
! 370: * jump to a quickfix line
! 371: * if dir == FORWARD go "errornr" valid entries forward
! 372: * if dir == BACKWARD go "errornr" valid entries backward
! 373: * else if "errornr" is zero, redisplay the same line
! 374: * else go to entry "errornr"
! 375: */
! 376: void
! 377: qf_jump(dir, errornr)
! 378: int dir;
! 379: int errornr;
! 380: {
! 381: struct qf_line *old_qf_ptr;
! 382: int old_qf_index;
! 383: static char_u *e_no_more_errors = (char_u *)"No more errors";
! 384: char_u *err = e_no_more_errors;
! 385: linenr_t i;
! 386:
! 387: if (qf_count == 0)
! 388: {
! 389: emsg(e_quickfix);
! 390: return;
! 391: }
! 392:
! 393: old_qf_ptr = qf_ptr;
! 394: old_qf_index = qf_index;
! 395: if (dir == FORWARD) /* next valid entry */
! 396: {
! 397: while (errornr--)
! 398: {
! 399: old_qf_ptr = qf_ptr;
! 400: old_qf_index = qf_index;
! 401: do
! 402: {
! 403: if (qf_index == qf_count || qf_ptr->qf_next == NULL)
! 404: {
! 405: qf_ptr = old_qf_ptr;
! 406: qf_index = old_qf_index;
! 407: if (err != NULL)
! 408: {
! 409: emsg(err);
! 410: return;
! 411: }
! 412: errornr = 0;
! 413: break;
! 414: }
! 415: ++qf_index;
! 416: qf_ptr = qf_ptr->qf_next;
! 417: } while (!qf_nonevalid && !qf_ptr->qf_valid);
! 418: err = NULL;
! 419: }
! 420: }
! 421: else if (dir == BACKWARD) /* previous valid entry */
! 422: {
! 423: while (errornr--)
! 424: {
! 425: old_qf_ptr = qf_ptr;
! 426: old_qf_index = qf_index;
! 427: do
! 428: {
! 429: if (qf_index == 1 || qf_ptr->qf_prev == NULL)
! 430: {
! 431: qf_ptr = old_qf_ptr;
! 432: qf_index = old_qf_index;
! 433: if (err != NULL)
! 434: {
! 435: emsg(err);
! 436: return;
! 437: }
! 438: errornr = 0;
! 439: break;
! 440: }
! 441: --qf_index;
! 442: qf_ptr = qf_ptr->qf_prev;
! 443: } while (!qf_nonevalid && !qf_ptr->qf_valid);
! 444: err = NULL;
! 445: }
! 446: }
! 447: else if (errornr != 0) /* go to specified number */
! 448: {
! 449: while (errornr < qf_index && qf_index > 1 && qf_ptr->qf_prev != NULL)
! 450: {
! 451: --qf_index;
! 452: qf_ptr = qf_ptr->qf_prev;
! 453: }
! 454: while (errornr > qf_index && qf_index < qf_count && qf_ptr->qf_next != NULL)
! 455: {
! 456: ++qf_index;
! 457: qf_ptr = qf_ptr->qf_next;
! 458: }
! 459: }
! 460:
! 461: /*
! 462: * If there is a file name,
! 463: * read the wanted file if needed, and check autowrite etc.
! 464: */
! 465: if (qf_ptr->qf_fnum == 0 || buflist_getfile(qf_ptr->qf_fnum,
! 466: (linenr_t)1, GETF_SETMARK) == OK)
! 467: {
! 468: /*
! 469: * Go to line with error, unless qf_lnum is 0.
! 470: */
! 471: i = qf_ptr->qf_lnum;
! 472: if (i > 0)
! 473: {
! 474: if (i > curbuf->b_ml.ml_line_count)
! 475: i = curbuf->b_ml.ml_line_count;
! 476: curwin->w_cursor.lnum = i;
! 477: }
! 478: if (qf_ptr->qf_col > 0)
! 479: {
! 480: curwin->w_cursor.col = qf_ptr->qf_col - 1;
! 481: adjust_cursor();
! 482: }
! 483: else
! 484: beginline(TRUE);
! 485: cursupdate();
! 486: smsg((char_u *)"(%d of %d)%s%s: %s", qf_index, qf_count,
! 487: qf_ptr->qf_cleared ? (char_u *)" (line deleted)" : (char_u *)"",
! 488: qf_types(qf_ptr->qf_type, qf_ptr->qf_nr), qf_ptr->qf_text);
! 489: /*
! 490: * if the message is short, redisplay after redrawing the screen
! 491: */
! 492: if (linetabsize(IObuff) < ((int)p_ch - 1) * Columns + sc_col)
! 493: keep_msg = IObuff;
! 494: }
! 495: else if (qf_ptr->qf_fnum != 0)
! 496: {
! 497: /*
! 498: * Couldn't open file, so put index back where it was. This could
! 499: * happen if the file was readonly and we changed something - webb
! 500: */
! 501: qf_ptr = old_qf_ptr;
! 502: qf_index = old_qf_index;
! 503: }
! 504: }
! 505:
! 506: /*
! 507: * list all errors
! 508: */
! 509: void
! 510: qf_list(all)
! 511: int all; /* If not :cl!, only show recognised errors */
! 512: {
! 513: BUF *buf;
! 514: char_u *fname;
! 515: struct qf_line *qfp;
! 516: int i;
! 517:
! 518: if (qf_count == 0)
! 519: {
! 520: emsg(e_quickfix);
! 521: return;
! 522: }
! 523:
! 524: if (qf_nonevalid)
! 525: all = TRUE;
! 526: qfp = qf_start;
! 527: set_highlight('d'); /* Same as for directories */
! 528: for (i = 1; !got_int && i <= qf_count; ++i)
! 529: {
! 530: if (qfp->qf_valid || all)
! 531: {
! 532: msg_outchar('\n');
! 533: start_highlight();
! 534: fname = NULL;
! 535: if (qfp->qf_fnum != 0 &&
! 536: (buf = buflist_findnr(qfp->qf_fnum)) != NULL)
! 537: fname = buf->b_xfilename;
! 538: if (fname == NULL)
! 539: sprintf((char *)IObuff, "%2d", i);
! 540: else
! 541: sprintf((char *)IObuff, "%2d %s", i, fname);
! 542: msg_outtrans(IObuff);
! 543: stop_highlight();
! 544: if (qfp->qf_lnum == 0)
! 545: IObuff[0] = NUL;
! 546: else if (qfp->qf_col == 0)
! 547: sprintf((char *)IObuff, ":%ld", qfp->qf_lnum);
! 548: else
! 549: sprintf((char *)IObuff, ":%ld, col %d",
! 550: qfp->qf_lnum, qfp->qf_col);
! 551: sprintf((char *)IObuff + STRLEN(IObuff), "%s: ",
! 552: qf_types(qfp->qf_type, qfp->qf_nr));
! 553: msg_outstr(IObuff);
! 554: msg_prt_line(qfp->qf_text);
! 555: flushbuf(); /* show one line at a time */
! 556: }
! 557: qfp = qfp->qf_next;
! 558: mch_breakcheck();
! 559: }
! 560: }
! 561:
! 562: /*
! 563: * free the error list
! 564: */
! 565: static void
! 566: qf_free()
! 567: {
! 568: struct qf_line *qfp;
! 569:
! 570: while (qf_count)
! 571: {
! 572: qfp = qf_start->qf_next;
! 573: vim_free(qf_start->qf_text);
! 574: vim_free(qf_start);
! 575: qf_start = qfp;
! 576: --qf_count;
! 577: }
! 578: }
! 579:
! 580: /*
! 581: * qf_mark_adjust: adjust marks
! 582: */
! 583: void
! 584: qf_mark_adjust(line1, line2, amount, amount_after)
! 585: linenr_t line1;
! 586: linenr_t line2;
! 587: long amount;
! 588: long amount_after;
! 589: {
! 590: register int i;
! 591: struct qf_line *qfp;
! 592:
! 593: if (qf_count)
! 594: for (i = 0, qfp = qf_start; i < qf_count; ++i, qfp = qfp->qf_next)
! 595: if (qfp->qf_fnum == curbuf->b_fnum)
! 596: {
! 597: if (qfp->qf_lnum >= line1 && qfp->qf_lnum <= line2)
! 598: {
! 599: if (amount == MAXLNUM)
! 600: qfp->qf_cleared = TRUE;
! 601: else
! 602: qfp->qf_lnum += amount;
! 603: }
! 604: if (amount_after && qfp->qf_lnum > line2)
! 605: qfp->qf_lnum += amount_after;
! 606: }
! 607: }
! 608:
! 609: /*
! 610: * Make a nice message out of the error character and the error number:
! 611: * char number message
! 612: * e or E 0 " error"
! 613: * w or W 0 " warning"
! 614: * other 0 ""
! 615: * w or W n " warning n"
! 616: * other n " error n"
! 617: */
! 618: static char_u *
! 619: qf_types(c, nr)
! 620: int c, nr;
! 621: {
! 622: static char_u buf[20];
! 623: char_u *p1;
! 624:
! 625: p1 = (char_u *)" error";
! 626: if (c == 'W' || c == 'w')
! 627: p1 = (char_u *)" warning";
! 628: else if (nr <= 0 && c != 'E' && c != 'e')
! 629: p1 = (char_u *)"";
! 630:
! 631: if (nr <= 0)
! 632: return p1;
! 633:
! 634: sprintf((char *)buf, "%s %3d", p1, nr);
! 635: return buf;
! 636: }