1 /* 2 * Copyright (C) 1984-2012 Mark Nudelman 3 * 4 * You may distribute under the terms of either the GNU General Public 5 * License or the Less License, as specified in the README file. 6 * 7 * For more information, see the README file. 8 */ 9 10 11 #include "less.h" 12 13 #define WHITESP(c) ((c)==' ' || (c)=='\t') 14 15 #if TAGS 16 17 public char *tags = "tags"; 18 19 static int total; 20 static int curseq; 21 22 extern int linenums; 23 extern int sigs; 24 25 enum tag_result { 26 TAG_FOUND, 27 TAG_NOFILE, 28 TAG_NOTAG, 29 TAG_NOTYPE, 30 TAG_INTR 31 }; 32 33 /* 34 * Tag type 35 */ 36 enum { 37 T_CTAGS, /* 'tags': standard and extended format (ctags) */ 38 T_CTAGS_X, /* stdin: cross reference format (ctags) */ 39 T_GTAGS, /* 'GTAGS': function defenition (global) */ 40 T_GRTAGS, /* 'GRTAGS': function reference (global) */ 41 T_GSYMS, /* 'GSYMS': other symbols (global) */ 42 T_GPATH /* 'GPATH': path name (global) */ 43 }; 44 45 static enum tag_result findctag(); 46 static enum tag_result findgtag(); 47 static char *nextgtag(); 48 static char *prevgtag(); 49 static POSITION ctagsearch(); 50 static POSITION gtagsearch(); 51 static int getentry(); 52 53 /* 54 * The list of tags generated by the last findgtag() call. 55 * 56 * Use either pattern or line number. 57 * findgtag() always uses line number, so pattern is always NULL. 58 * findctag() uses either pattern (in which case line number is 0), 59 * or line number (in which case pattern is NULL). 60 */ 61 struct taglist { 62 struct tag *tl_first; 63 struct tag *tl_last; 64 }; 65 #define TAG_END ((struct tag *) &taglist) 66 static struct taglist taglist = { TAG_END, TAG_END }; 67 struct tag { 68 struct tag *next, *prev; /* List links */ 69 char *tag_file; /* Source file containing the tag */ 70 LINENUM tag_linenum; /* Appropriate line number in source file */ 71 char *tag_pattern; /* Pattern used to find the tag */ 72 char tag_endline; /* True if the pattern includes '$' */ 73 }; 74 static struct tag *curtag; 75 76 #define TAG_INS(tp) \ 77 (tp)->next = TAG_END; \ 78 (tp)->prev = taglist.tl_last; \ 79 taglist.tl_last->next = (tp); \ 80 taglist.tl_last = (tp); 81 82 #define TAG_RM(tp) \ 83 (tp)->next->prev = (tp)->prev; \ 84 (tp)->prev->next = (tp)->next; 85 86 /* 87 * Delete tag structures. 88 */ 89 public void 90 cleantags() 91 { 92 register struct tag *tp; 93 94 /* 95 * Delete any existing tag list. 96 * {{ Ideally, we wouldn't do this until after we know that we 97 * can load some other tag information. }} 98 */ 99 while ((tp = taglist.tl_first) != TAG_END) 100 { 101 TAG_RM(tp); 102 free(tp); 103 } 104 curtag = NULL; 105 total = curseq = 0; 106 } 107 108 /* 109 * Create a new tag entry. 110 */ 111 static struct tag * 112 maketagent(name, file, linenum, pattern, endline) 113 char *name; 114 char *file; 115 LINENUM linenum; 116 char *pattern; 117 int endline; 118 { 119 register struct tag *tp; 120 121 tp = (struct tag *) ecalloc(sizeof(struct tag), 1); 122 tp->tag_file = (char *) ecalloc(strlen(file) + 1, sizeof(char)); 123 strcpy(tp->tag_file, file); 124 tp->tag_linenum = linenum; 125 tp->tag_endline = endline; 126 if (pattern == NULL) 127 tp->tag_pattern = NULL; 128 else 129 { 130 tp->tag_pattern = (char *) ecalloc(strlen(pattern) + 1, sizeof(char)); 131 strcpy(tp->tag_pattern, pattern); 132 } 133 return (tp); 134 } 135 136 /* 137 * Get tag mode. 138 */ 139 public int 140 gettagtype() 141 { 142 int f; 143 144 if (strcmp(tags, "GTAGS") == 0) 145 return T_GTAGS; 146 if (strcmp(tags, "GRTAGS") == 0) 147 return T_GRTAGS; 148 if (strcmp(tags, "GSYMS") == 0) 149 return T_GSYMS; 150 if (strcmp(tags, "GPATH") == 0) 151 return T_GPATH; 152 if (strcmp(tags, "-") == 0) 153 return T_CTAGS_X; 154 f = open(tags, OPEN_READ); 155 if (f >= 0) 156 { 157 close(f); 158 return T_CTAGS; 159 } 160 return T_GTAGS; 161 } 162 163 /* 164 * Find tags in tag file. 165 * Find a tag in the "tags" file. 166 * Sets "tag_file" to the name of the file containing the tag, 167 * and "tagpattern" to the search pattern which should be used 168 * to find the tag. 169 */ 170 public void 171 findtag(tag) 172 register char *tag; 173 { 174 int type = gettagtype(); 175 enum tag_result result; 176 177 if (type == T_CTAGS) 178 result = findctag(tag); 179 else 180 result = findgtag(tag, type); 181 switch (result) 182 { 183 case TAG_FOUND: 184 case TAG_INTR: 185 break; 186 case TAG_NOFILE: 187 error("No tags file", NULL_PARG); 188 break; 189 case TAG_NOTAG: 190 error("No such tag in tags file", NULL_PARG); 191 break; 192 case TAG_NOTYPE: 193 error("unknown tag type", NULL_PARG); 194 break; 195 } 196 } 197 198 /* 199 * Search for a tag. 200 */ 201 public POSITION 202 tagsearch() 203 { 204 if (curtag == NULL) 205 return (NULL_POSITION); /* No gtags loaded! */ 206 if (curtag->tag_linenum != 0) 207 return gtagsearch(); 208 else 209 return ctagsearch(); 210 } 211 212 /* 213 * Go to the next tag. 214 */ 215 public char * 216 nexttag(n) 217 int n; 218 { 219 char *tagfile = (char *) NULL; 220 221 while (n-- > 0) 222 tagfile = nextgtag(); 223 return tagfile; 224 } 225 226 /* 227 * Go to the previous tag. 228 */ 229 public char * 230 prevtag(n) 231 int n; 232 { 233 char *tagfile = (char *) NULL; 234 235 while (n-- > 0) 236 tagfile = prevgtag(); 237 return tagfile; 238 } 239 240 /* 241 * Return the total number of tags. 242 */ 243 public int 244 ntags() 245 { 246 return total; 247 } 248 249 /* 250 * Return the sequence number of current tag. 251 */ 252 public int 253 curr_tag() 254 { 255 return curseq; 256 } 257 258 /***************************************************************************** 259 * ctags 260 */ 261 262 /* 263 * Find tags in the "tags" file. 264 * Sets curtag to the first tag entry. 265 */ 266 static enum tag_result 267 findctag(tag) 268 register char *tag; 269 { 270 char *p; 271 register FILE *f; 272 register int taglen; 273 LINENUM taglinenum; 274 char *tagfile; 275 char *tagpattern; 276 int tagendline; 277 int search_char; 278 int err; 279 char tline[TAGLINE_SIZE]; 280 struct tag *tp; 281 282 p = shell_unquote(tags); 283 f = fopen(p, "r"); 284 free(p); 285 if (f == NULL) 286 return TAG_NOFILE; 287 288 cleantags(); 289 total = 0; 290 taglen = strlen(tag); 291 292 /* 293 * Search the tags file for the desired tag. 294 */ 295 while (fgets(tline, sizeof(tline), f) != NULL) 296 { 297 if (tline[0] == '!') 298 /* Skip header of extended format. */ 299 continue; 300 if (strncmp(tag, tline, taglen) != 0 || !WHITESP(tline[taglen])) 301 continue; 302 303 /* 304 * Found it. 305 * The line contains the tag, the filename and the 306 * location in the file, separated by white space. 307 * The location is either a decimal line number, 308 * or a search pattern surrounded by a pair of delimiters. 309 * Parse the line and extract these parts. 310 */ 311 tagpattern = NULL; 312 313 /* 314 * Skip over the whitespace after the tag name. 315 */ 316 p = skipsp(tline+taglen); 317 if (*p == '\0') 318 /* File name is missing! */ 319 continue; 320 321 /* 322 * Save the file name. 323 * Skip over the whitespace after the file name. 324 */ 325 tagfile = p; 326 while (!WHITESP(*p) && *p != '\0') 327 p++; 328 *p++ = '\0'; 329 p = skipsp(p); 330 if (*p == '\0') 331 /* Pattern is missing! */ 332 continue; 333 334 /* 335 * First see if it is a line number. 336 */ 337 tagendline = 0; 338 taglinenum = getnum(&p, 0, &err); 339 if (err) 340 { 341 /* 342 * No, it must be a pattern. 343 * Delete the initial "^" (if present) and 344 * the final "$" from the pattern. 345 * Delete any backslash in the pattern. 346 */ 347 taglinenum = 0; 348 search_char = *p++; 349 if (*p == '^') 350 p++; 351 tagpattern = p; 352 while (*p != search_char && *p != '\0') 353 { 354 if (*p == '\\') 355 p++; 356 p++; 357 } 358 tagendline = (p[-1] == '$'); 359 if (tagendline) 360 p--; 361 *p = '\0'; 362 } 363 tp = maketagent(tag, tagfile, taglinenum, tagpattern, tagendline); 364 TAG_INS(tp); 365 total++; 366 } 367 fclose(f); 368 if (total == 0) 369 return TAG_NOTAG; 370 curtag = taglist.tl_first; 371 curseq = 1; 372 return TAG_FOUND; 373 } 374 375 /* 376 * Edit current tagged file. 377 */ 378 public int 379 edit_tagfile() 380 { 381 if (curtag == NULL) 382 return (1); 383 return (edit(curtag->tag_file)); 384 } 385 386 /* 387 * Search for a tag. 388 * This is a stripped-down version of search(). 389 * We don't use search() for several reasons: 390 * - We don't want to blow away any search string we may have saved. 391 * - The various regular-expression functions (from different systems: 392 * regcmp vs. re_comp) behave differently in the presence of 393 * parentheses (which are almost always found in a tag). 394 */ 395 static POSITION 396 ctagsearch() 397 { 398 POSITION pos, linepos; 399 LINENUM linenum; 400 int len; 401 char *line; 402 403 pos = ch_zero(); 404 linenum = find_linenum(pos); 405 406 for (;;) 407 { 408 /* 409 * Get lines until we find a matching one or 410 * until we hit end-of-file. 411 */ 412 if (ABORT_SIGS()) 413 return (NULL_POSITION); 414 415 /* 416 * Read the next line, and save the 417 * starting position of that line in linepos. 418 */ 419 linepos = pos; 420 pos = forw_raw_line(pos, &line, (int *)NULL); 421 if (linenum != 0) 422 linenum++; 423 424 if (pos == NULL_POSITION) 425 { 426 /* 427 * We hit EOF without a match. 428 */ 429 error("Tag not found", NULL_PARG); 430 return (NULL_POSITION); 431 } 432 433 /* 434 * If we're using line numbers, we might as well 435 * remember the information we have now (the position 436 * and line number of the current line). 437 */ 438 if (linenums) 439 add_lnum(linenum, pos); 440 441 /* 442 * Test the line to see if we have a match. 443 * Use strncmp because the pattern may be 444 * truncated (in the tags file) if it is too long. 445 * If tagendline is set, make sure we match all 446 * the way to end of line (no extra chars after the match). 447 */ 448 len = strlen(curtag->tag_pattern); 449 if (strncmp(curtag->tag_pattern, line, len) == 0 && 450 (!curtag->tag_endline || line[len] == '\0' || line[len] == '\r')) 451 { 452 curtag->tag_linenum = find_linenum(linepos); 453 break; 454 } 455 } 456 457 return (linepos); 458 } 459 460 /******************************************************************************* 461 * gtags 462 */ 463 464 /* 465 * Find tags in the GLOBAL's tag file. 466 * The findgtag() will try and load information about the requested tag. 467 * It does this by calling "global -x tag" and storing the parsed output 468 * for future use by gtagsearch(). 469 * Sets curtag to the first tag entry. 470 */ 471 static enum tag_result 472 findgtag(tag, type) 473 char *tag; /* tag to load */ 474 int type; /* tags type */ 475 { 476 char buf[256]; 477 FILE *fp; 478 struct tag *tp; 479 480 if (type != T_CTAGS_X && tag == NULL) 481 return TAG_NOFILE; 482 483 cleantags(); 484 total = 0; 485 486 /* 487 * If type == T_CTAGS_X then read ctags's -x format from stdin 488 * else execute global(1) and read from it. 489 */ 490 if (type == T_CTAGS_X) 491 { 492 fp = stdin; 493 /* Set tag default because we cannot read stdin again. */ 494 tags = "tags"; 495 } else 496 { 497 #if !HAVE_POPEN 498 return TAG_NOFILE; 499 #else 500 char *command; 501 char *flag; 502 char *qtag; 503 char *cmd = lgetenv("LESSGLOBALTAGS"); 504 505 if (cmd == NULL || *cmd == '\0') 506 return TAG_NOFILE; 507 /* Get suitable flag value for global(1). */ 508 switch (type) 509 { 510 case T_GTAGS: 511 flag = "" ; 512 break; 513 case T_GRTAGS: 514 flag = "r"; 515 break; 516 case T_GSYMS: 517 flag = "s"; 518 break; 519 case T_GPATH: 520 flag = "P"; 521 break; 522 default: 523 return TAG_NOTYPE; 524 } 525 526 /* Get our data from global(1). */ 527 qtag = shell_quote(tag); 528 if (qtag == NULL) 529 qtag = tag; 530 command = (char *) ecalloc(strlen(cmd) + strlen(flag) + 531 strlen(qtag) + 5, sizeof(char)); 532 sprintf(command, "%s -x%s %s", cmd, flag, qtag); 533 if (qtag != tag) 534 free(qtag); 535 fp = popen(command, "r"); 536 free(command); 537 #endif 538 } 539 if (fp != NULL) 540 { 541 while (fgets(buf, sizeof(buf), fp)) 542 { 543 char *name, *file, *line; 544 int len; 545 546 if (sigs) 547 { 548 #if HAVE_POPEN 549 if (fp != stdin) 550 pclose(fp); 551 #endif 552 return TAG_INTR; 553 } 554 len = strlen(buf); 555 if (len > 0 && buf[len-1] == '\n') 556 buf[len-1] = '\0'; 557 else 558 { 559 int c; 560 do { 561 c = fgetc(fp); 562 } while (c != '\n' && c != EOF); 563 } 564 565 if (getentry(buf, &name, &file, &line)) 566 { 567 /* 568 * Couldn't parse this line for some reason. 569 * We'll just pretend it never happened. 570 */ 571 break; 572 } 573 574 /* Make new entry and add to list. */ 575 tp = maketagent(name, file, (LINENUM) atoi(line), NULL, 0); 576 TAG_INS(tp); 577 total++; 578 } 579 if (fp != stdin) 580 { 581 if (pclose(fp)) 582 { 583 curtag = NULL; 584 total = curseq = 0; 585 return TAG_NOFILE; 586 } 587 } 588 } 589 590 /* Check to see if we found anything. */ 591 tp = taglist.tl_first; 592 if (tp == TAG_END) 593 return TAG_NOTAG; 594 curtag = tp; 595 curseq = 1; 596 return TAG_FOUND; 597 } 598 599 static int circular = 0; /* 1: circular tag structure */ 600 601 /* 602 * Return the filename required for the next gtag in the queue that was setup 603 * by findgtag(). The next call to gtagsearch() will try to position at the 604 * appropriate tag. 605 */ 606 static char * 607 nextgtag() 608 { 609 struct tag *tp; 610 611 if (curtag == NULL) 612 /* No tag loaded */ 613 return NULL; 614 615 tp = curtag->next; 616 if (tp == TAG_END) 617 { 618 if (!circular) 619 return NULL; 620 /* Wrapped around to the head of the queue */ 621 curtag = taglist.tl_first; 622 curseq = 1; 623 } else 624 { 625 curtag = tp; 626 curseq++; 627 } 628 return (curtag->tag_file); 629 } 630 631 /* 632 * Return the filename required for the previous gtag in the queue that was 633 * setup by findgtat(). The next call to gtagsearch() will try to position 634 * at the appropriate tag. 635 */ 636 static char * 637 prevgtag() 638 { 639 struct tag *tp; 640 641 if (curtag == NULL) 642 /* No tag loaded */ 643 return NULL; 644 645 tp = curtag->prev; 646 if (tp == TAG_END) 647 { 648 if (!circular) 649 return NULL; 650 /* Wrapped around to the tail of the queue */ 651 curtag = taglist.tl_last; 652 curseq = total; 653 } else 654 { 655 curtag = tp; 656 curseq--; 657 } 658 return (curtag->tag_file); 659 } 660 661 /* 662 * Position the current file at at what is hopefully the tag that was chosen 663 * using either findtag() or one of nextgtag() and prevgtag(). Returns -1 664 * if it was unable to position at the tag, 0 if successful. 665 */ 666 static POSITION 667 gtagsearch() 668 { 669 if (curtag == NULL) 670 return (NULL_POSITION); /* No gtags loaded! */ 671 return (find_pos(curtag->tag_linenum)); 672 } 673 674 /* 675 * The getentry() parses both standard and extended ctags -x format. 676 * 677 * [standard format] 678 * <tag> <lineno> <file> <image> 679 * +------------------------------------------------ 680 * |main 30 main.c main(argc, argv) 681 * |func 21 subr.c func(arg) 682 * 683 * The following commands write this format. 684 * o Traditinal Ctags with -x option 685 * o Global with -x option 686 * See <http://www.gnu.org/software/global/global.html> 687 * 688 * [extended format] 689 * <tag> <type> <lineno> <file> <image> 690 * +---------------------------------------------------------- 691 * |main function 30 main.c main(argc, argv) 692 * |func function 21 subr.c func(arg) 693 * 694 * The following commands write this format. 695 * o Exuberant Ctags with -x option 696 * See <http://ctags.sourceforge.net> 697 * 698 * Returns 0 on success, -1 on error. 699 * The tag, file, and line will each be NUL-terminated pointers 700 * into buf. 701 */ 702 static int 703 getentry(buf, tag, file, line) 704 char *buf; /* standard or extended ctags -x format data */ 705 char **tag; /* name of the tag we actually found */ 706 char **file; /* file in which to find this tag */ 707 char **line; /* line number of file where this tag is found */ 708 { 709 char *p = buf; 710 711 for (*tag = p; *p && !IS_SPACE(*p); p++) /* tag name */ 712 ; 713 if (*p == 0) 714 return (-1); 715 *p++ = 0; 716 for ( ; *p && IS_SPACE(*p); p++) /* (skip blanks) */ 717 ; 718 if (*p == 0) 719 return (-1); 720 /* 721 * If the second part begin with other than digit, 722 * it is assumed tag type. Skip it. 723 */ 724 if (!IS_DIGIT(*p)) 725 { 726 for ( ; *p && !IS_SPACE(*p); p++) /* (skip tag type) */ 727 ; 728 for (; *p && IS_SPACE(*p); p++) /* (skip blanks) */ 729 ; 730 } 731 if (!IS_DIGIT(*p)) 732 return (-1); 733 *line = p; /* line number */ 734 for (*line = p; *p && !IS_SPACE(*p); p++) 735 ; 736 if (*p == 0) 737 return (-1); 738 *p++ = 0; 739 for ( ; *p && IS_SPACE(*p); p++) /* (skip blanks) */ 740 ; 741 if (*p == 0) 742 return (-1); 743 *file = p; /* file name */ 744 for (*file = p; *p && !IS_SPACE(*p); p++) 745 ; 746 if (*p == 0) 747 return (-1); 748 *p = 0; 749 750 /* value check */ 751 if (strlen(*tag) && strlen(*line) && strlen(*file) && atoi(*line) > 0) 752 return (0); 753 return (-1); 754 } 755 756 #endif 757