Annotation of src/usr.bin/vim/tag.c, Revision 1.1
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: * Code to handle tags and the tag stack
! 12: */
! 13:
! 14: #include "vim.h"
! 15: #include "globals.h"
! 16: #include "proto.h"
! 17: #include "option.h"
! 18:
! 19: static int get_tagfname __ARGS((int, char_u *));
! 20:
! 21: #ifdef EMACS_TAGS
! 22: static int parse_tag_line __ARGS((char_u *, int,
! 23: char_u **, char_u **, char_u **, char_u **, char_u **));
! 24: static int jumpto_tag __ARGS((char_u *, int, char_u *, char_u *));
! 25: #else
! 26: static int parse_tag_line __ARGS((char_u *,
! 27: char_u **, char_u **, char_u **, char_u **, char_u **));
! 28: static int jumpto_tag __ARGS((char_u *, char_u *));
! 29: #endif
! 30: static int test_for_static __ARGS((char_u **, char_u *, char_u *, char_u *));
! 31: static char_u *expand_rel_name __ARGS((char_u *fname, char_u *tag_fname));
! 32: static void simplify_filename __ARGS((char_u *filename));
! 33: #ifdef EMACS_TAGS
! 34: static int test_for_current __ARGS((int, char_u *, char_u *, char_u *));
! 35: #else
! 36: static int test_for_current __ARGS((char_u *, char_u *, char_u *));
! 37: #endif
! 38:
! 39: static char_u *bottommsg = (char_u *)"at bottom of tag stack";
! 40: static char_u *topmsg = (char_u *)"at top of tag stack";
! 41:
! 42: /*
! 43: * Jump to tag; handling of tag stack
! 44: *
! 45: * *tag != NUL (:tag): jump to new tag, add to tag stack
! 46: * type == 1 (:pop) || type == 2 (CTRL-T): jump to old position
! 47: * type == 0 (:tag): jump to old tag
! 48: */
! 49: void
! 50: do_tag(tag, type, count)
! 51: char_u *tag;
! 52: int type;
! 53: int count;
! 54: {
! 55: int i;
! 56: struct taggy *tagstack = curwin->w_tagstack;
! 57: int tagstackidx = curwin->w_tagstackidx;
! 58: int tagstacklen = curwin->w_tagstacklen;
! 59: int oldtagstackidx = tagstackidx;
! 60:
! 61: if (*tag != NUL) /* new pattern, add to the stack */
! 62: {
! 63: /*
! 64: * if last used entry is not at the top, delete all tag stack entries
! 65: * above it.
! 66: */
! 67: while (tagstackidx < tagstacklen)
! 68: vim_free(tagstack[--tagstacklen].tagname);
! 69:
! 70: /* if tagstack is full: remove oldest entry */
! 71: if (++tagstacklen > TAGSTACKSIZE)
! 72: {
! 73: tagstacklen = TAGSTACKSIZE;
! 74: vim_free(tagstack[0].tagname);
! 75: for (i = 1; i < tagstacklen; ++i)
! 76: tagstack[i - 1] = tagstack[i];
! 77: --tagstackidx;
! 78: }
! 79:
! 80: /*
! 81: * put the tag name in the tag stack
! 82: * the position is added below
! 83: */
! 84: tagstack[tagstackidx].tagname = strsave(tag);
! 85: }
! 86: else if (tagstacklen == 0) /* empty stack */
! 87: {
! 88: EMSG("tag stack empty");
! 89: goto end_do_tag;
! 90: }
! 91: else if (type) /* go to older position */
! 92: {
! 93: if ((tagstackidx -= count) < 0)
! 94: {
! 95: emsg(bottommsg);
! 96: if (tagstackidx + count == 0)
! 97: {
! 98: /* We did ^T (or <num>^T) from the bottom of the stack */
! 99: tagstackidx = 0;
! 100: goto end_do_tag;
! 101: }
! 102: /* We weren't at the bottom of the stack, so jump all the way to
! 103: * the bottom.
! 104: */
! 105: tagstackidx = 0;
! 106: }
! 107: else if (tagstackidx >= tagstacklen) /* must have been count == 0 */
! 108: {
! 109: emsg(topmsg);
! 110: goto end_do_tag;
! 111: }
! 112: if (tagstack[tagstackidx].fmark.fnum != curbuf->b_fnum)
! 113: {
! 114: /*
! 115: * Jump to other file. If this fails (e.g. because the file was
! 116: * changed) keep original position in tag stack.
! 117: */
! 118: if (buflist_getfile(tagstack[tagstackidx].fmark.fnum,
! 119: tagstack[tagstackidx].fmark.mark.lnum, GETF_SETMARK) == FAIL)
! 120: {
! 121: tagstackidx = oldtagstackidx; /* back to old position */
! 122: goto end_do_tag;
! 123: }
! 124: }
! 125: else
! 126: curwin->w_cursor.lnum = tagstack[tagstackidx].fmark.mark.lnum;
! 127: curwin->w_cursor.col = tagstack[tagstackidx].fmark.mark.col;
! 128: curwin->w_set_curswant = TRUE;
! 129: goto end_do_tag;
! 130: }
! 131: else /* go to newer pattern */
! 132: {
! 133: if ((tagstackidx += count - 1) >= tagstacklen)
! 134: {
! 135: /*
! 136: * beyond the last one, just give an error message and go to the
! 137: * last one
! 138: */
! 139: tagstackidx = tagstacklen - 1;
! 140: emsg(topmsg);
! 141: }
! 142: else if (tagstackidx < 0) /* must have been count == 0 */
! 143: {
! 144: emsg(bottommsg);
! 145: tagstackidx = 0;
! 146: goto end_do_tag;
! 147: }
! 148: }
! 149: /*
! 150: * For :tag [arg], remember position before the jump
! 151: */
! 152: if (type == 0)
! 153: {
! 154: tagstack[tagstackidx].fmark.mark = curwin->w_cursor;
! 155: tagstack[tagstackidx].fmark.fnum = curbuf->b_fnum;
! 156: }
! 157: /* curwin will change in the call to find_tags() if ^W^] was used -- webb */
! 158: curwin->w_tagstackidx = tagstackidx;
! 159: curwin->w_tagstacklen = tagstacklen;
! 160: if (find_tags(tagstack[tagstackidx].tagname, NULL, NULL, NULL, FALSE) > 0)
! 161: ++tagstackidx;
! 162:
! 163: end_do_tag:
! 164: curwin->w_tagstackidx = tagstackidx;
! 165: curwin->w_tagstacklen = tagstacklen;
! 166: }
! 167:
! 168: /*
! 169: * Print the tag stack
! 170: */
! 171: void
! 172: do_tags()
! 173: {
! 174: int i;
! 175: char_u *name;
! 176: struct taggy *tagstack = curwin->w_tagstack;
! 177: int tagstackidx = curwin->w_tagstackidx;
! 178: int tagstacklen = curwin->w_tagstacklen;
! 179:
! 180: set_highlight('t'); /* Highlight title */
! 181: start_highlight();
! 182: MSG_OUTSTR("\n # TO tag FROM line in file");
! 183: stop_highlight();
! 184: for (i = 0; i < tagstacklen; ++i)
! 185: {
! 186: if (tagstack[i].tagname != NULL)
! 187: {
! 188: name = fm_getname(&(tagstack[i].fmark));
! 189: if (name == NULL) /* file name not available */
! 190: continue;
! 191:
! 192: msg_outchar('\n');
! 193: sprintf((char *)IObuff, "%c%2d %-15s %4ld %s",
! 194: i == tagstackidx ? '>' : ' ',
! 195: i + 1,
! 196: tagstack[i].tagname,
! 197: tagstack[i].fmark.mark.lnum,
! 198: name);
! 199: msg_outtrans(IObuff);
! 200: }
! 201: flushbuf(); /* show one line at a time */
! 202: }
! 203: if (tagstackidx == tagstacklen) /* idx at top of stack */
! 204: MSG_OUTSTR("\n>");
! 205: }
! 206:
! 207: /*
! 208: * find_tags() - goto tag or search for tags in tags files
! 209: *
! 210: * If "tag" is not NULL, search for a single tag and jump to it.
! 211: * return FAIL for failure, OK for success
! 212: * If "tag" is NULL, find all tags matching the regexp given with 'prog'.
! 213: * return FAIL if search completely failed, OK otherwise.
! 214: *
! 215: * There is a priority in which type of tag is recognized. It is computed
! 216: * from the PRI_ defines below.
! 217: *
! 218: * 6. A static or global tag with a full matching tag for the current file.
! 219: * 5. A global tag with a full matching tag for another file.
! 220: * 4. A static tag with a full matching tag for another file.
! 221: * 2. A static or global tag with an ignore-case matching tag for the
! 222: * current file.
! 223: * 1. A global tag with an ignore-case matching tag for another file.
! 224: * 0. A static tag with an ignore-case matching tag for another file.
! 225: *
! 226: * Tags in an emacs-style tags file are always global.
! 227: */
! 228: #define PRI_GLOBAL 1 /* global or emacs tag */
! 229: #define PRI_CURRENT 2 /* tag for current file */
! 230: #define PRI_FULL_MATCH 4 /* case of tag matches */
! 231:
! 232: int
! 233: find_tags(tag, prog, num_file, file, help_only)
! 234: char_u *tag; /* NULL or tag to search for */
! 235: regexp *prog; /* regexp program or NULL */
! 236: int *num_file; /* return value: number of matches found */
! 237: char_u ***file; /* return value: array of matches found */
! 238: int help_only; /* if TRUE: only tags for help files */
! 239: {
! 240: FILE *fp;
! 241: char_u *lbuf; /* line buffer */
! 242: char_u *tag_fname; /* name of tag file */
! 243: int first_file; /* trying first tag file */
! 244: char_u *tagname, *tagname_end; /* name of tag in current line */
! 245: char_u *fname, *fname_end; /* fname in current line */
! 246: int did_open = FALSE; /* did open a tag file */
! 247: int stop_searching = FALSE; /* stop when match found or error */
! 248: int retval = FAIL; /* return value */
! 249: int is_static; /* current tag line is static */
! 250: int is_current; /* file name matches */
! 251: register char_u *p;
! 252: #ifdef EMACS_TAGS
! 253: char_u *ebuf; /* aditional buffer for etag fname */
! 254: int is_etag; /* current file is emaces style */
! 255: #endif
! 256:
! 257: /*
! 258: * Variables used only when "tag" != NULL
! 259: */
! 260: int taglen = 0; /* init for GCC */
! 261: int cmplen;
! 262: int full_match;
! 263: int icase_match;
! 264: int priority; /* priority of current line */
! 265:
! 266: char_u *bestmatch_line = NULL; /* saved line for best match found so
! 267: far */
! 268: char_u *bestmatch_tag_fname = NULL;
! 269: /* copy of tag_fname for best match */
! 270: int bestmatch_priority = 0; /* best match priority */
! 271:
! 272: #ifdef EMACS_TAGS
! 273: /*
! 274: * Stack for included emacs-tags file.
! 275: * It has a fixed size, to truncate cyclic includes. jw
! 276: */
! 277: # define INCSTACK_SIZE 42
! 278: struct
! 279: {
! 280: FILE *fp;
! 281: char_u *tag_fname;
! 282: } incstack[INCSTACK_SIZE];
! 283:
! 284: int incstack_idx = 0; /* index in incstack */
! 285: char_u *bestmatch_ebuf = NULL; /* copy of ebuf for best match */
! 286: int bestmatch_is_etag = FALSE; /* copy of is_etag for best match */
! 287: #endif
! 288:
! 289: /*
! 290: * Variables used when "tag" == NULL
! 291: */
! 292: char_u **matches = NULL; /* array of matches found */
! 293: char_u **new_matches;
! 294: int match_limit = 100; /* max. number of matches stored */
! 295: int match_count = 0; /* number of matches found */
! 296: int i;
! 297: int help_save;
! 298:
! 299: help_save = curbuf->b_help;
! 300: /*
! 301: * Allocate memory for the buffers that are used
! 302: */
! 303: lbuf = alloc(LSIZE);
! 304: #ifdef EMACS_TAGS
! 305: ebuf = alloc(LSIZE);
! 306: #endif
! 307: tag_fname = alloc(LSIZE + 1);
! 308: /* check for out of memory situation */
! 309: if ((tag == NULL && prog == NULL) || lbuf == NULL || tag_fname == NULL
! 310: #ifdef EMACS_TAGS
! 311: || ebuf == NULL
! 312: #endif
! 313: )
! 314: goto findtag_end;
! 315: if (tag == NULL)
! 316: {
! 317: matches = (char_u **)alloc((unsigned)(match_limit * sizeof(char_u *)));
! 318: if (matches == NULL)
! 319: goto findtag_end;
! 320: }
! 321:
! 322: /*
! 323: * Initialize a few variables
! 324: */
! 325: if (tag != NULL)
! 326: {
! 327: taglen = STRLEN(tag);
! 328: if (p_tl != 0 && taglen > p_tl) /* adjust for 'taglength' */
! 329: taglen = p_tl;
! 330: }
! 331: else if (help_only) /* want tags from help file */
! 332: curbuf->b_help = TRUE;
! 333:
! 334: /*
! 335: * Try tag file names from tags option one by one.
! 336: */
! 337: for (first_file = TRUE; get_tagfname(first_file, tag_fname) == OK;
! 338: first_file = FALSE)
! 339: {
! 340: /*
! 341: * A file that doesn't exist is silently ignored.
! 342: */
! 343: if ((fp = fopen((char *)tag_fname, "r")) == NULL)
! 344: continue;
! 345: did_open = TRUE; /* remember that we found at least one file */
! 346:
! 347: #ifdef EMACS_TAGS
! 348: is_etag = 0; /* default is: not emacs style */
! 349: #endif
! 350: /*
! 351: * Read and parse the lines in the file one by one
! 352: */
! 353: while (!got_int)
! 354: {
! 355: line_breakcheck();
! 356:
! 357: if (vim_fgets(lbuf, LSIZE, fp))
! 358: #ifdef EMACS_TAGS
! 359: if (incstack_idx) /* this was an included file */
! 360: {
! 361: --incstack_idx;
! 362: fclose(fp); /* end of this file ... */
! 363: fp = incstack[incstack_idx].fp;
! 364: STRCPY(tag_fname, incstack[incstack_idx].tag_fname);
! 365: vim_free(incstack[incstack_idx].tag_fname);
! 366: is_etag = 1; /* (only etags can include) */
! 367: continue; /* ... continue with parent file */
! 368: }
! 369: else
! 370: #endif
! 371: break; /* end of file */
! 372:
! 373: #ifdef EMACS_TAGS
! 374: /*
! 375: * Emacs tags line with CTRL-L: New file name on next line.
! 376: * The file name is followed by a ','.
! 377: */
! 378: if (*lbuf == Ctrl('L')) /* remember etag filename in ebuf */
! 379: {
! 380: is_etag = 1;
! 381: if (!vim_fgets(ebuf, LSIZE, fp))
! 382: {
! 383: for (p = ebuf; *p && *p != ','; p++)
! 384: ;
! 385: *p = NUL;
! 386:
! 387: /*
! 388: * atoi(p+1) is the number of bytes before the next ^L
! 389: * unless it is an include statement.
! 390: */
! 391: if (STRNCMP(p + 1, "include", 7) == 0 &&
! 392: incstack_idx < INCSTACK_SIZE)
! 393: {
! 394: if ((incstack[incstack_idx].tag_fname =
! 395: strsave(tag_fname)) != NULL)
! 396: {
! 397: incstack[incstack_idx].fp = fp;
! 398: if ((fp = fopen((char *)ebuf, "r")) == NULL)
! 399: {
! 400: fp = incstack[incstack_idx].fp;
! 401: vim_free(incstack[incstack_idx].tag_fname);
! 402: }
! 403: else
! 404: {
! 405: STRCPY(tag_fname, ebuf);
! 406: ++incstack_idx;
! 407: }
! 408: is_etag = 0; /* we can include anything */
! 409: }
! 410: }
! 411: }
! 412: continue;
! 413: }
! 414: #endif
! 415:
! 416: /*
! 417: * Figure out where the different strings are in this line.
! 418: * For "normal" tags: Do a quick check if the tag matches.
! 419: * This speeds up tag searching a lot!
! 420: */
! 421: if (tag != NULL
! 422: #ifdef EMACS_TAGS
! 423: && !is_etag
! 424: #endif
! 425: )
! 426: {
! 427: tagname = lbuf;
! 428: fname = NULL;
! 429: for (tagname_end = lbuf; *tagname_end &&
! 430: !vim_iswhite(*tagname_end); ++tagname_end)
! 431: {
! 432: if (*tagname_end == ':')
! 433: {
! 434: if (fname == NULL)
! 435: fname = skipwhite(skiptowhite(tagname_end));
! 436: if (fnamencmp(lbuf, fname, tagname_end - lbuf) == 0 &&
! 437: vim_iswhite(fname[tagname_end - lbuf]))
! 438: tagname = tagname_end + 1;
! 439: }
! 440: }
! 441:
! 442: /*
! 443: * Skip this line if the lenght of the tag is different.
! 444: */
! 445: cmplen = tagname_end - tagname;
! 446: if (p_tl != 0 && cmplen > p_tl) /* adjust for 'taglength' */
! 447: cmplen = p_tl;
! 448: if (taglen != cmplen)
! 449: continue;
! 450:
! 451: /*
! 452: * Skip this line if the tag does not match (ignoring case).
! 453: */
! 454: if (vim_strnicmp(tagname, tag, (size_t)cmplen))
! 455: continue;
! 456:
! 457: /*
! 458: * This is a useful tag, isolate the filename.
! 459: */
! 460: if (fname == NULL)
! 461: fname = skipwhite(skiptowhite(tagname_end));
! 462: fname_end = skiptowhite(fname);
! 463: if (*fname_end == NUL)
! 464: i = FAIL;
! 465: else
! 466: i = OK;
! 467: }
! 468: else
! 469: i = parse_tag_line(lbuf,
! 470: #ifdef EMACS_TAGS
! 471: is_etag,
! 472: #endif
! 473: &tagname, &tagname_end, &fname, &fname_end, NULL);
! 474: if (i == FAIL)
! 475: {
! 476: EMSG2("Format error in tags file \"%s\"", tag_fname);
! 477: stop_searching = TRUE;
! 478: break;
! 479: }
! 480:
! 481: #ifdef EMACS_TAGS
! 482: is_static = FALSE;
! 483: if (!is_etag) /* emacs tags are never static */
! 484: #endif
! 485: is_static = test_for_static(&tagname, tagname_end,
! 486: fname, fname_end);
! 487: #ifdef EMACS_TAGS
! 488: if (is_etag)
! 489: fname = ebuf;
! 490: #endif
! 491: /*
! 492: * "tag" == NULL: find tags matching regexp "prog"
! 493: */
! 494: if (tag == NULL)
! 495: {
! 496: *tagname_end = NUL;
! 497: if (vim_regexec(prog, tagname, TRUE))
! 498: {
! 499: is_current = test_for_current(
! 500: #ifdef EMACS_TAGS
! 501: is_etag,
! 502: #endif
! 503: fname, fname_end, tag_fname);
! 504: if (!is_static || is_current)
! 505: {
! 506: /*
! 507: * Found a match, add it to matches[].
! 508: * May need to make matches[] larger.
! 509: */
! 510: if (match_count == match_limit)
! 511: {
! 512: match_limit += 100;
! 513: new_matches = (char_u **)alloc(
! 514: (unsigned)(match_limit * sizeof(char_u *)));
! 515: if (new_matches == NULL)
! 516: {
! 517: /* Out of memory! Just forget about the rest
! 518: * of the matches. */
! 519: retval = OK;
! 520: stop_searching = TRUE;
! 521: break;
! 522: }
! 523: for (i = 0; i < match_count; i++)
! 524: new_matches[i] = matches[i];
! 525: vim_free(matches);
! 526: matches = new_matches;
! 527: }
! 528: if (help_only)
! 529: {
! 530: int len;
! 531:
! 532: /*
! 533: * Append the help-heuristic number after the
! 534: * tagname, for sorting it later.
! 535: */
! 536: len = STRLEN(tagname);
! 537: p = alloc(len + 10);
! 538: if (p != NULL)
! 539: {
! 540: STRCPY(p, tagname);
! 541: sprintf((char *)p + len + 1, "%06d",
! 542: help_heuristic(tagname,
! 543: (int)(prog->startp[0] - tagname)));
! 544: }
! 545: matches[match_count++] = p;
! 546: }
! 547: else
! 548: matches[match_count++] = strsave(tagname);
! 549: }
! 550: }
! 551: }
! 552: /*
! 553: * "tag" != NULL: find tag and jump to it
! 554: */
! 555: else
! 556: {
! 557: /*
! 558: * If tag length does not match, skip the rest
! 559: */
! 560: cmplen = tagname_end - tagname;
! 561: if (p_tl != 0 && cmplen > p_tl) /* adjust for 'taglength' */
! 562: cmplen = p_tl;
! 563: if (taglen == cmplen)
! 564: {
! 565: /*
! 566: * Check for match (ignoring case).
! 567: */
! 568: icase_match = (vim_strnicmp(tagname, tag,
! 569: (size_t)cmplen) == 0);
! 570: if (icase_match) /* Tag matches somehow */
! 571: {
! 572: /*
! 573: * If it's a full match for the current file, jump to
! 574: * it now.
! 575: */
! 576: full_match = (STRNCMP(tagname, tag, cmplen) == 0);
! 577: is_current = test_for_current(
! 578: #ifdef EMACS_TAGS
! 579: is_etag,
! 580: #endif
! 581: fname, fname_end, tag_fname);
! 582: if (full_match && is_current)
! 583: {
! 584: retval = jumpto_tag(lbuf,
! 585: #ifdef EMACS_TAGS
! 586: is_etag, ebuf,
! 587: #endif
! 588: tag_fname);
! 589: stop_searching = TRUE;
! 590: break;
! 591: }
! 592:
! 593: /*
! 594: * If the priority of the current line is higher than
! 595: * the best match so far, store it as the best match
! 596: */
! 597: if (full_match)
! 598: priority = PRI_FULL_MATCH;
! 599: else
! 600: priority = 0;
! 601: if (is_current)
! 602: priority += PRI_CURRENT;
! 603: if (!is_static)
! 604: priority += PRI_GLOBAL;
! 605:
! 606: if (priority > bestmatch_priority)
! 607: {
! 608: vim_free(bestmatch_line);
! 609: bestmatch_line = strsave(lbuf);
! 610: vim_free(bestmatch_tag_fname);
! 611: bestmatch_tag_fname = strsave(tag_fname);
! 612: bestmatch_priority = priority;
! 613: #ifdef EMACS_TAGS
! 614: bestmatch_is_etag = is_etag;
! 615: if (is_etag)
! 616: {
! 617: vim_free(bestmatch_ebuf);
! 618: bestmatch_ebuf = strsave(ebuf);
! 619: }
! 620: #endif
! 621: }
! 622: }
! 623: }
! 624: }
! 625: }
! 626: fclose(fp);
! 627: #ifdef EMACS_TAGS
! 628: while (incstack_idx)
! 629: {
! 630: --incstack_idx;
! 631: fclose(incstack[incstack_idx].fp);
! 632: vim_free(incstack[incstack_idx].tag_fname);
! 633: }
! 634: #endif
! 635: if (stop_searching)
! 636: break;
! 637:
! 638: /*
! 639: * Stop searching if a tag was found in the current tags file and
! 640: * we got a global match with matching case or 'ignorecase' is set.
! 641: */
! 642: if (tag != NULL && bestmatch_line != NULL &&
! 643: bestmatch_priority >= (p_ic ? 0 : PRI_FULL_MATCH) + PRI_GLOBAL)
! 644: break;
! 645: }
! 646:
! 647: if (!stop_searching)
! 648: {
! 649: if (!did_open) /* never opened any tags file */
! 650: EMSG("No tags file");
! 651: else if (tag == NULL)
! 652: {
! 653: retval = OK; /* It's OK even when no tag found */
! 654: }
! 655: else
! 656: {
! 657: /*
! 658: * If we didn't find a static full match, use the best match found.
! 659: */
! 660: if (bestmatch_line != NULL)
! 661: {
! 662: if (bestmatch_priority < PRI_FULL_MATCH)
! 663: {
! 664: MSG("Only found tag with different case!");
! 665: if (!msg_scrolled)
! 666: {
! 667: flushbuf();
! 668: mch_delay(1000L, TRUE);
! 669: }
! 670: }
! 671: retval = jumpto_tag(bestmatch_line,
! 672: #ifdef EMACS_TAGS
! 673: bestmatch_is_etag, bestmatch_ebuf,
! 674: #endif
! 675: bestmatch_tag_fname);
! 676: }
! 677: else
! 678: EMSG("tag not found");
! 679: }
! 680: }
! 681:
! 682: findtag_end:
! 683: vim_free(lbuf);
! 684: vim_free(tag_fname);
! 685: vim_free(bestmatch_line);
! 686: vim_free(bestmatch_tag_fname);
! 687: #ifdef EMACS_TAGS
! 688: vim_free(ebuf);
! 689: vim_free(bestmatch_ebuf);
! 690: #endif
! 691:
! 692: if (tag == NULL)
! 693: {
! 694: if (retval == FAIL) /* free all matches found */
! 695: while (match_count > 0)
! 696: vim_free(matches[--match_count]);
! 697: if (match_count == 0) /* nothing found, free matches[] */
! 698: {
! 699: vim_free(matches);
! 700: matches = NULL;
! 701: }
! 702: *file = matches;
! 703: *num_file = match_count;
! 704: }
! 705: curbuf->b_help = help_save;
! 706:
! 707: return retval;
! 708: }
! 709:
! 710: /*
! 711: * Get the next name of a tag file from the tag file list.
! 712: * For help files, use "vim_tags" file only.
! 713: *
! 714: * Return FAIL if no more tag file names, OK otherwise.
! 715: */
! 716: static int
! 717: get_tagfname(first, buf)
! 718: int first; /* TRUE when first file name is wanted */
! 719: char_u *buf; /* pointer to buffer of LSIZE chars */
! 720: {
! 721: static char_u *np = NULL;
! 722: char_u *fname;
! 723: size_t path_len, fname_len;
! 724: /*
! 725: * A list is made of the files that have been visited.
! 726: */
! 727: struct visited
! 728: {
! 729: struct visited *v_next;
! 730: #if defined(UNIX)
! 731: struct stat v_st;
! 732: #else
! 733: char_u v_fname[1]; /* actually longer */
! 734: #endif
! 735: };
! 736: static struct visited *first_visited = NULL;
! 737: struct visited *vp;
! 738: #if defined(UNIX)
! 739: struct stat st;
! 740: #endif
! 741:
! 742: if (first)
! 743: {
! 744: np = p_tags;
! 745: while (first_visited != NULL)
! 746: {
! 747: vp = first_visited->v_next;
! 748: vim_free(first_visited);
! 749: first_visited = vp;
! 750: }
! 751: }
! 752:
! 753: if (np == NULL) /* tried allready (or bogus call) */
! 754: return FAIL;
! 755:
! 756: /*
! 757: * For a help window only try the file 'vim_tags' in the same
! 758: * directory as 'helpfile'.
! 759: */
! 760: if (curbuf->b_help)
! 761: {
! 762: path_len = gettail(p_hf) - p_hf;
! 763: if (path_len + 9 >= LSIZE)
! 764: return FAIL;
! 765: vim_memmove(buf, p_hf, path_len);
! 766: STRCPY(buf + path_len, "vim_tags");
! 767:
! 768: np = NULL; /* try only once */
! 769: }
! 770:
! 771: else
! 772: {
! 773: /*
! 774: * Loop until we have found a file name that can be used.
! 775: */
! 776: for (;;)
! 777: {
! 778: if (*np == NUL) /* tried all possibilities */
! 779: return FAIL;
! 780:
! 781: /*
! 782: * Copy next file name into buf.
! 783: */
! 784: (void)copy_option_part(&np, buf, LSIZE, " ,");
! 785:
! 786: /*
! 787: * Tag file name starting with "./": Replace '.' with path of
! 788: * current file.
! 789: */
! 790: if (buf[0] == '.' && ispathsep(buf[1]))
! 791: {
! 792: if (curbuf->b_filename == NULL) /* skip if no filename */
! 793: continue;
! 794:
! 795: path_len = gettail(curbuf->b_filename) - curbuf->b_filename;
! 796: fname = buf + 1;
! 797: while (ispathsep(*fname)) /* skip '/' and the like */
! 798: ++fname;
! 799: fname_len = STRLEN(fname);
! 800: if (fname_len + path_len + 1 > LSIZE)
! 801: continue;
! 802: vim_memmove(buf + path_len, fname, fname_len + 1);
! 803: vim_memmove(buf, curbuf->b_filename, path_len);
! 804: }
! 805:
! 806: /*
! 807: * Check if this tags file has been used already.
! 808: * If file doesn't exist, skip it.
! 809: */
! 810: #if defined(UNIX)
! 811: if (stat((char *)buf, &st) < 0)
! 812: #else
! 813: if (FullName(buf, NameBuff, MAXPATHL, TRUE) == FAIL)
! 814: #endif
! 815: continue;
! 816:
! 817: for (vp = first_visited; vp != NULL; vp = vp->v_next)
! 818: #if defined(UNIX)
! 819: if (vp->v_st.st_dev == st.st_dev &&
! 820: vp->v_st.st_ino == st.st_ino)
! 821: #else
! 822: if (fnamecmp(vp->v_fname, NameBuff) == 0)
! 823: #endif
! 824: break;
! 825:
! 826: if (vp != NULL) /* already visited, skip it */
! 827: continue;
! 828:
! 829: /*
! 830: * Found the next name. Add it to the list of visited files.
! 831: */
! 832: #if defined(UNIX)
! 833: vp = (struct visited *)alloc((unsigned)sizeof(struct visited));
! 834: #else
! 835: vp = (struct visited *)alloc((unsigned)(sizeof(struct visited) +
! 836: STRLEN(NameBuff)));
! 837: #endif
! 838: if (vp != NULL)
! 839: {
! 840: #if defined(UNIX)
! 841: vp->v_st = st;
! 842: #else
! 843: STRCPY(vp->v_fname, NameBuff);
! 844: #endif
! 845: vp->v_next = first_visited;
! 846: first_visited = vp;
! 847: }
! 848: break;
! 849: }
! 850: }
! 851: return OK;
! 852: }
! 853:
! 854: /*
! 855: * Parse one line from the tags file. Find start/end of tag name, start/end of
! 856: * file name and start of search pattern.
! 857: *
! 858: * If is_etag is TRUE, fname and fname_end are not set.
! 859: * If command == NULL it is not set.
! 860: *
! 861: * Return FAIL if there is a format error in this line, OK otherwise.
! 862: */
! 863: static int
! 864: parse_tag_line(lbuf,
! 865: #ifdef EMACS_TAGS
! 866: is_etag,
! 867: #endif
! 868: tagname, tagname_end, fname, fname_end, command)
! 869: char_u *lbuf;
! 870: #ifdef EMACS_TAGS
! 871: int is_etag;
! 872: #endif
! 873: char_u **tagname;
! 874: char_u **tagname_end;
! 875: char_u **fname;
! 876: char_u **fname_end;
! 877: char_u **command;
! 878: {
! 879: char_u *p;
! 880:
! 881: #ifdef EMACS_TAGS
! 882: char_u *p_7f;
! 883:
! 884: if (is_etag)
! 885: {
! 886: /*
! 887: * There are two formats for an emacs tag line:
! 888: * 1: struct EnvBase ^?EnvBase^A139,4627
! 889: * 2: #define ARPB_WILD_WORLD ^?153,5194
! 890: */
! 891: p_7f = vim_strchr(lbuf, 0x7f);
! 892: if (p_7f == NULL)
! 893: return FAIL;
! 894: /* find start of line number */
! 895: for (p = p_7f + 1; *p < '0' || *p > '9'; ++p)
! 896: if (*p == NUL)
! 897: return FAIL;
! 898: if (command != NULL)
! 899: *command = p;
! 900:
! 901: /* first format: explicit tagname given */
! 902: if (p[-1] == Ctrl('A'))
! 903: {
! 904: *tagname = p_7f + 1;
! 905: *tagname_end = p - 1;
! 906: }
! 907: else
! 908: /* second format: isolate tagname */
! 909: {
! 910: /* find end of tagname */
! 911: for (p = p_7f - 1; *p == ' ' || *p == '\t' ||
! 912: *p == '(' || *p == ';'; --p)
! 913: if (p == lbuf)
! 914: return FAIL;
! 915: *tagname_end = p + 1;
! 916: while (p >= lbuf && *p != ' ' && *p != '\t')
! 917: --p;
! 918: *tagname = p + 1;
! 919: }
! 920: }
! 921: else
! 922: {
! 923: #endif
! 924: /* Isolate the tagname, from lbuf up to the first white */
! 925: *tagname = lbuf;
! 926: p = skiptowhite(lbuf);
! 927: if (*p == NUL)
! 928: return FAIL;
! 929: *tagname_end = p;
! 930:
! 931: /* Isolate file name, from first to second white space */
! 932: p = skipwhite(p);
! 933: *fname = p;
! 934: p = skiptowhite(p);
! 935: if (*p == NUL)
! 936: return FAIL;
! 937: *fname_end = p;
! 938:
! 939: /* find start of search command, after second white space */
! 940: if (command != NULL)
! 941: {
! 942: p = skipwhite(p);
! 943: if (*p == NUL)
! 944: return FAIL;
! 945: *command = p;
! 946: }
! 947: #ifdef EMACS_TAGS
! 948: }
! 949: #endif
! 950:
! 951: return OK;
! 952: }
! 953:
! 954: /*
! 955: * Check if tagname is a static tag
! 956: *
! 957: * Static tags produced by the ctags program have the
! 958: * format: 'file:tag file /pattern'.
! 959: * This is only recognized when both occurences of 'file'
! 960: * are the same, to avoid recognizing "string::string" or
! 961: * ":exit".
! 962: *
! 963: * Return TRUE if it is a static tag and adjust *tagname to the real tag.
! 964: * Return FALSE if it is not a static tag.
! 965: */
! 966: static int
! 967: test_for_static(tagname, tagname_end, fname, fname_end)
! 968: char_u **tagname;
! 969: char_u *tagname_end;
! 970: char_u *fname;
! 971: char_u *fname_end;
! 972: {
! 973: char_u *p;
! 974:
! 975: p = *tagname + (fname_end - fname);
! 976: if (p < tagname_end && *p == ':' &&
! 977: fnamencmp(*tagname, fname, fname_end - fname) == 0)
! 978: {
! 979: *tagname = p + 1;
! 980: return TRUE;
! 981: }
! 982: return FALSE;
! 983: }
! 984:
! 985: /*
! 986: * Jump to a tag that has been found in one of the tag files
! 987: */
! 988: static int
! 989: jumpto_tag(lbuf,
! 990: #ifdef EMACS_TAGS
! 991: is_etag, etag_fname,
! 992: #endif
! 993: tag_fname)
! 994: char_u *lbuf; /* line from the tags file for this tag */
! 995: #ifdef EMACS_TAGS
! 996: int is_etag; /* TRUE if it's from an emacs tags file */
! 997: char_u *etag_fname; /* file name for tag if is_etag is TRUE */
! 998: #endif
! 999: char_u *tag_fname; /* file name of the tags file itself */
! 1000: {
! 1001: int save_secure;
! 1002: int save_p_ws, save_p_scs, save_p_ic;
! 1003: char_u *str;
! 1004: char_u *pbuf; /* search pattern buffer */
! 1005: char_u *p;
! 1006: char_u *expanded_fname = NULL;
! 1007: char_u *tagname, *tagname_end;
! 1008: char_u *fname, *fname_end;
! 1009: char_u *orig_fname;
! 1010: int retval = FAIL;
! 1011: int getfile_result;
! 1012: int search_options;
! 1013:
! 1014: pbuf = alloc(LSIZE);
! 1015:
! 1016: if (pbuf == NULL
! 1017: #ifdef EMACS_TAGS
! 1018: || (is_etag && etag_fname == NULL)
! 1019: #endif
! 1020: || tag_fname == NULL)
! 1021: goto erret;
! 1022:
! 1023: /*
! 1024: * find the search pattern (caller should check it is there)
! 1025: */
! 1026: if (parse_tag_line(lbuf,
! 1027: #ifdef EMACS_TAGS
! 1028: is_etag,
! 1029: #endif
! 1030: &tagname, &tagname_end, &fname, &fname_end, &str) == FAIL)
! 1031: goto erret;
! 1032: orig_fname = fname; /* remember for test_for_static() below */
! 1033:
! 1034: #ifdef EMACS_TAGS
! 1035: if (is_etag)
! 1036: fname = etag_fname;
! 1037: else
! 1038: #endif
! 1039: *fname_end = NUL;
! 1040:
! 1041: /*
! 1042: * If the command is a string like "/^function fname"
! 1043: * scan through the search string. If we see a magic
! 1044: * char, we have to quote it. This lets us use "real"
! 1045: * implementations of ctags.
! 1046: */
! 1047: if (*str == '/' || *str == '?')
! 1048: {
! 1049: p = pbuf;
! 1050: *p++ = *str++; /* copy the '/' or '?' */
! 1051: if (*str == '^')
! 1052: *p++ = *str++; /* copy the '^' */
! 1053:
! 1054: while (*str)
! 1055: {
! 1056: switch (*str)
! 1057: {
! 1058: /* Always remove '\' before '('.
! 1059: * Remove a '\' befor '*' if 'nomagic'.
! 1060: * Otherwise just copy the '\' and don't look at the
! 1061: * next character
! 1062: */
! 1063: case '\\': if (str[1] == '(' || (!p_magic && str[1] == '*'))
! 1064: ++str;
! 1065: else
! 1066: *p++ = *str++;
! 1067: break;
! 1068:
! 1069: case '\r':
! 1070: case '\n': *str = pbuf[0]; /* copy '/' or '?' */
! 1071: str[1] = NUL; /* delete NL after CR */
! 1072: break;
! 1073:
! 1074: /*
! 1075: * if string ends in search character: skip it
! 1076: * else escape it with '\'
! 1077: */
! 1078: case '/':
! 1079: case '?': if (*str != pbuf[0]) /* not the search char */
! 1080: break;
! 1081: /* last char */
! 1082: if (str[1] == '\n' || str[1] == '\r')
! 1083: {
! 1084: ++str;
! 1085: continue;
! 1086: }
! 1087: case '[':
! 1088: if (!p_magic)
! 1089: break;
! 1090: case '^':
! 1091: case '*':
! 1092: case '~':
! 1093: case '.': *p++ = '\\';
! 1094: break;
! 1095: }
! 1096: *p++ = *str++;
! 1097: }
! 1098: }
! 1099: else /* not a search command, just copy it */
! 1100: {
! 1101: for (p = pbuf; *str && *str != '\n'; )
! 1102: {
! 1103: #ifdef EMACS_TAGS
! 1104: if (is_etag && *str == ',') /* stop at ',' after line number */
! 1105: break;
! 1106: #endif
! 1107: *p++ = *str++;
! 1108: }
! 1109: }
! 1110: *p = NUL;
! 1111:
! 1112: /*
! 1113: * expand filename (for environment variables)
! 1114: */
! 1115: expanded_fname = ExpandOne((char_u *)fname, NULL, WILD_LIST_NOTFOUND,
! 1116: WILD_EXPAND_FREE);
! 1117: if (expanded_fname != NULL)
! 1118: fname = expanded_fname;
! 1119:
! 1120: /*
! 1121: * if 'tagrelative' option set, may change file name
! 1122: */
! 1123: fname = expand_rel_name(fname, tag_fname);
! 1124:
! 1125: /*
! 1126: * check if file for tag exists before abandoning current file
! 1127: */
! 1128: if (getperm(fname) < 0)
! 1129: {
! 1130: EMSG2("File \"%s\" does not exist", fname);
! 1131: goto erret;
! 1132: }
! 1133:
! 1134: ++RedrawingDisabled;
! 1135: /*
! 1136: * if it was a CTRL-W CTRL-] command split window now
! 1137: */
! 1138: if (postponed_split)
! 1139: win_split(0, FALSE);
! 1140: /*
! 1141: * A :ta from a help file will keep the b_help flag set.
! 1142: */
! 1143: keep_help_flag = curbuf->b_help;
! 1144: getfile_result = getfile(0, fname, NULL, TRUE, (linenr_t)0);
! 1145:
! 1146: if (getfile_result <= 0) /* got to the right file */
! 1147: {
! 1148: curwin->w_set_curswant = TRUE;
! 1149: postponed_split = FALSE;
! 1150:
! 1151: save_secure = secure;
! 1152: secure = 1;
! 1153: /*
! 1154: * If 'cpoptions' contains 't', store the search pattern for the "n"
! 1155: * command. If 'cpoptions' does not contain 't', the search pattern
! 1156: * is not stored.
! 1157: */
! 1158: if (vim_strchr(p_cpo, CPO_TAGPAT) != NULL)
! 1159: search_options = 0;
! 1160: else
! 1161: search_options = SEARCH_KEEP;
! 1162:
! 1163: /*
! 1164: * if the command is a search, try here
! 1165: *
! 1166: * Rather than starting at line one, just turn wrap-scan
! 1167: * on temporarily, this ensures that tags on line 1 will
! 1168: * be found, and makes sure our guess searches search the
! 1169: * whole file when repeated -- webb.
! 1170: * Also reset 'smartcase' for the search, since the search
! 1171: * pattern was not typed by the user.
! 1172: */
! 1173: if (pbuf[0] == '/' || pbuf[0] == '?')
! 1174: {
! 1175: save_p_ws = p_ws;
! 1176: save_p_ic = p_ic;
! 1177: save_p_scs = p_scs;
! 1178: p_ws = TRUE; /* Switch wrap-scan on temporarily */
! 1179: p_ic = FALSE; /* don't ignore case now */
! 1180: p_scs = FALSE;
! 1181: add_to_history(1, pbuf + 1); /* put pattern in search history */
! 1182:
! 1183: if (do_search(pbuf[0], pbuf + 1, (long)1, search_options))
! 1184: retval = OK;
! 1185: else
! 1186: {
! 1187: register int notfound = FALSE;
! 1188:
! 1189: /*
! 1190: * try again, ignore case now
! 1191: */
! 1192: p_ic = TRUE;
! 1193: if (!do_search(pbuf[0], pbuf + 1, (long)1, search_options))
! 1194: {
! 1195: /*
! 1196: * Failed to find pattern, take a guess: "^func ("
! 1197: */
! 1198: (void)test_for_static(&tagname, tagname_end,
! 1199: orig_fname, fname_end);
! 1200: *tagname_end = NUL;
! 1201: sprintf((char *)pbuf, "^%s[ \t]*(", tagname);
! 1202: if (!do_search('/', pbuf, (long)1, search_options))
! 1203: {
! 1204: /* Guess again: "^char * func (" */
! 1205: sprintf((char *)pbuf, "^[#a-zA-Z_].*%s[ \t]*(",
! 1206: tagname);
! 1207: if (!do_search('/', pbuf, (long)1, search_options))
! 1208: notfound = TRUE;
! 1209: }
! 1210: }
! 1211: if (notfound)
! 1212: EMSG("Can't find tag pattern");
! 1213: else
! 1214: {
! 1215: MSG("Couldn't find tag, just guessing!");
! 1216: if (!msg_scrolled)
! 1217: {
! 1218: flushbuf();
! 1219: mch_delay(1000L, TRUE);
! 1220: }
! 1221: retval = OK;
! 1222: }
! 1223: }
! 1224: p_ws = save_p_ws;
! 1225: p_ic = save_p_ic;
! 1226: p_scs = save_p_scs;
! 1227: }
! 1228: else
! 1229: { /* start command in line 1 */
! 1230: curwin->w_cursor.lnum = 1;
! 1231: do_cmdline(pbuf, TRUE, TRUE);
! 1232: retval = OK;
! 1233: }
! 1234:
! 1235: if (secure == 2) /* done something that is not allowed */
! 1236: wait_return(TRUE);
! 1237: secure = save_secure;
! 1238:
! 1239: /*
! 1240: * Print the file message after redraw if jumped to another file.
! 1241: * Don't do this for help files (avoid a hit-return message).
! 1242: */
! 1243: if (getfile_result == -1)
! 1244: {
! 1245: if (!curbuf->b_help)
! 1246: need_fileinfo = TRUE;
! 1247: retval = OK; /* always return OK if jumped to another
! 1248: file (at least we found the file!) */
! 1249: }
! 1250:
! 1251: /*
! 1252: * For a help buffer: Put the cursor line at the top of the window,
! 1253: * the help subject will be below it.
! 1254: */
! 1255: if (curbuf->b_help)
! 1256: {
! 1257: curwin->w_topline = curwin->w_cursor.lnum;
! 1258: comp_Botline(curwin);
! 1259: cursupdate(); /* take care of 'scrolloff' */
! 1260: updateScreen(NOT_VALID);
! 1261: }
! 1262: --RedrawingDisabled;
! 1263: }
! 1264: else
! 1265: {
! 1266: --RedrawingDisabled;
! 1267: if (postponed_split) /* close the window */
! 1268: {
! 1269: close_window(curwin, FALSE);
! 1270: postponed_split = FALSE;
! 1271: }
! 1272: }
! 1273:
! 1274: erret:
! 1275: vim_free(pbuf);
! 1276: vim_free(expanded_fname);
! 1277:
! 1278: return retval;
! 1279: }
! 1280:
! 1281: /*
! 1282: * If 'tagrelative' option set, change fname (name of file containing tag)
! 1283: * according to tag_fname (name of tag file containing fname).
! 1284: */
! 1285: static char_u *
! 1286: expand_rel_name(fname, tag_fname)
! 1287: char_u *fname;
! 1288: char_u *tag_fname;
! 1289: {
! 1290: char_u *p;
! 1291:
! 1292: if ((p_tr || curbuf->b_help) && !isFullName(fname) &&
! 1293: (p = gettail(tag_fname)) != tag_fname)
! 1294: {
! 1295: STRCPY(NameBuff, tag_fname);
! 1296: STRNCPY(NameBuff + (p - tag_fname), fname,
! 1297: MAXPATHL - (p - tag_fname));
! 1298: /*
! 1299: * Translate names like "src/a/../b/file.c" into "src/b/file.c".
! 1300: */
! 1301: simplify_filename(NameBuff);
! 1302: fname = NameBuff;
! 1303: }
! 1304: return fname;
! 1305: }
! 1306:
! 1307: /*
! 1308: * Moves the tail part of the path (including the terminating NUL) pointed to
! 1309: * by "tail" to the new location pointed to by "here". This should accomodate
! 1310: * an overlapping move.
! 1311: */
! 1312: #define movetail(here, tail) vim_memmove(here, tail, STRLEN(tail) + (size_t)1)
! 1313:
! 1314: /*
! 1315: * For MS-DOS we should check for backslash too, but that is complicated.
! 1316: */
! 1317: #define DIR_SEP '/' /* the directory separator character */
! 1318:
! 1319: /*
! 1320: * Converts a filename into a canonical form. It simplifies a filename into
! 1321: * its simplest form by stripping out unneeded components, if any. The
! 1322: * resulting filename is simplified in place and will either be the same
! 1323: * length as that supplied, or shorter.
! 1324: */
! 1325: static void
! 1326: simplify_filename(filename)
! 1327: char_u *filename;
! 1328: {
! 1329: int absolute = FALSE;
! 1330: int components = 0;
! 1331: char_u *p, *tail;
! 1332:
! 1333: p = filename;
! 1334: if (*p == DIR_SEP)
! 1335: {
! 1336: absolute = TRUE;
! 1337: ++p;
! 1338: }
! 1339: do
! 1340: {
! 1341: /* Always leave "p" pointing to character following next "/". */
! 1342: if (*p == DIR_SEP)
! 1343: movetail(p, p+1); /* strip duplicate "/" */
! 1344: else if (STRNCMP(p, "./", 2) == 0)
! 1345: movetail(p, p+2); /* strip "./" */
! 1346: else if (STRNCMP(p, "../", 3) == 0)
! 1347: {
! 1348: if (components > 0) /* strip any prev. component */
! 1349: {
! 1350: *(p - 1) = 0; /* delete "/" before "../" */
! 1351: tail = p + 2; /* skip to "/" of "../" */
! 1352: p = vim_strrchr(filename, DIR_SEP); /* find preceding sep. */
! 1353: if (p != NULL) /* none found */
! 1354: ++p; /* skip to char after "/" */
! 1355: else
! 1356: {
! 1357: ++tail; /* strip leading "/" from tail*/
! 1358: p = filename; /* go back to beginning */
! 1359: if (absolute) /* skip over any leading "/" */
! 1360: ++p;
! 1361: }
! 1362: movetail(p, tail); /* strip previous component */
! 1363: --components;
! 1364: }
! 1365: else if (absolute) /* no parent to root... */
! 1366: movetail(p, p+3); /* so strip "../" */
! 1367: else /* leading series of "../" */
! 1368: {
! 1369: p = vim_strchr(p, DIR_SEP); /* skip to next "/" */
! 1370: if (p != NULL)
! 1371: ++p; /* skip to char after "/" */
! 1372: }
! 1373: }
! 1374: else
! 1375: {
! 1376: ++components; /* simple path component */
! 1377: p = vim_strchr(p, DIR_SEP); /* skip to next "/" */
! 1378: if (p != NULL)
! 1379: ++p; /* skip to char after "/" */
! 1380: }
! 1381: } while (p != NULL && *p != NUL);
! 1382: }
! 1383:
! 1384: /*
! 1385: * Check if we have a tag for the current file.
! 1386: * This is a bit slow, because of the full path compare in fullpathcmp().
! 1387: * Return TRUE if tag for file "fname" if tag file "tag_fname" is for current
! 1388: * file.
! 1389: */
! 1390: static int
! 1391: #ifdef EMACS_TAGS
! 1392: test_for_current(is_etag, fname, fname_end, tag_fname)
! 1393: int is_etag;
! 1394: #else
! 1395: test_for_current(fname, fname_end, tag_fname)
! 1396: #endif
! 1397: char_u *fname;
! 1398: char_u *fname_end;
! 1399: char_u *tag_fname;
! 1400: {
! 1401: int c;
! 1402: int retval;
! 1403:
! 1404: if (curbuf->b_filename == NULL)
! 1405: retval = FALSE;
! 1406: else
! 1407: {
! 1408: #ifdef EMACS_TAGS
! 1409: if (is_etag)
! 1410: c = 0; /* to shut up GCC */
! 1411: else
! 1412: #endif
! 1413: {
! 1414: c = *fname_end;
! 1415: *fname_end = NUL;
! 1416: }
! 1417: retval = (fullpathcmp(expand_rel_name(fname, tag_fname),
! 1418: curbuf->b_xfilename) == FPC_SAME);
! 1419: #ifdef EMACS_TAGS
! 1420: if (!is_etag)
! 1421: #endif
! 1422: *fname_end = c;
! 1423: }
! 1424:
! 1425: return retval;
! 1426: }
![[BACK]](/icons/back.gif){kind=icon}
Return to tag.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / vim