contrib/nvi/ex/ex_cscope.c

   1 /*-
   2  * Copyright (c) 1994, 1996
   3  *      Rob Mayoff.  All rights reserved.
   4  * Copyright (c) 1996
   5  *      Keith Bostic.  All rights reserved.
   6  *
   7  * See the LICENSE file for redistribution information.
   8  */
   9
  10 #include "config.h"
  11
  12 #ifndef lint
  13 static const char sccsid[] = "@(#)ex_cscope.c   10.13 (Berkeley) 9/15/96";
  14 #endif /* not lint */
  15
  16 #include <sys/param.h>
  17 #include <sys/types.h>          /* XXX: param.h may not have included types.h */
  18 #include <sys/queue.h>
  19 #include <sys/stat.h>
  20 #include <sys/time.h>
  21 #include <sys/wait.h>
  22
  23 #include <bitstring.h>
  24 #include <ctype.h>
  25 #include <errno.h>
  26 #include <fcntl.h>
  27 #include <limits.h>
  28 #include <stddef.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <termios.h>
  33 #include <unistd.h>
  34
  35 #include "../common/common.h"
  36 #include "pathnames.h"
  37 #include "tag.h"
  38
  39 #define CSCOPE_DBFILE           "cscope.out"
  40 #define CSCOPE_PATHS            "cscope.tpath"
  41
  42 /*
  43  * 0name        find all uses of name
  44  * 1name        find definition of name
  45  * 2name        find all function calls made from name
  46  * 3name        find callers of name
  47  * 4string      find text string (cscope 12.9)
  48  * 4name        find assignments to name (cscope 13.3)
  49  * 5pattern     change pattern -- NOT USED
  50  * 6pattern     find pattern
  51  * 7name        find files with name as substring
  52  * 8name        find files #including name
  53  */
  54 #define FINDHELP "\
  55 find c|d|e|f|g|i|s|t buffer|pattern\n\
  56       c: find callers of name\n\
  57       d: find all function calls made from name\n\
  58       e: find pattern\n\
  59       f: find files with name as substring\n\
  60       g: find definition of name\n\
  61       i: find files #including name\n\
  62       s: find all uses of name\n\
  63       t: find assignments to name"
  64
  65 static int cscope_add __P((SCR *, EXCMD *, char *));
  66 static int cscope_find __P((SCR *, EXCMD*, char *));
  67 static int cscope_help __P((SCR *, EXCMD *, char *));
  68 static int cscope_kill __P((SCR *, EXCMD *, char *));
  69 static int cscope_reset __P((SCR *, EXCMD *, char *));
  70
  71 typedef struct _cc {
  72         char     *name;
  73         int     (*function) __P((SCR *, EXCMD *, char *));
  74         char     *help_msg;
  75         char     *usage_msg;
  76 } CC;
  77
  78 static CC const cscope_cmds[] = {
  79         { "add",   cscope_add,
  80           "Add a new cscope database", "add file | directory" },
  81         { "find",  cscope_find,
  82           "Query the databases for a pattern", FINDHELP },
  83         { "help",  cscope_help,
  84           "Show help for cscope commands", "help [command]" },
  85         { "kill",  cscope_kill,
  86           "Kill a cscope connection", "kill number" },
  87         { "reset", cscope_reset,
  88           "Discard all current cscope connections", "reset" },
  89         { NULL }
  90 };
  91
  92 static TAGQ     *create_cs_cmd __P((SCR *, char *, size_t *));
  93 static int       csc_help __P((SCR *, char *));
  94 static void      csc_file __P((SCR *,
  95                     CSC *, char *, char **, size_t *, int *));
  96 static int       get_paths __P((SCR *, CSC *));
  97 static CC const *lookup_ccmd __P((char *));
  98 static int       parse __P((SCR *, CSC *, TAGQ *, int *));
  99 static int       read_prompt __P((SCR *, CSC *));
 100 static int       run_cscope __P((SCR *, CSC *, char *));
 101 static int       start_cscopes __P((SCR *, EXCMD *));
 102 static int       terminate __P((SCR *, CSC *, int));
 103
 104 /*
 105  * ex_cscope --
 106  *      Perform an ex cscope.
 107  *
 108  * PUBLIC: int ex_cscope __P((SCR *, EXCMD *));
 109  */
 110 int
 111 ex_cscope(sp, cmdp)
 112         SCR *sp;
 113         EXCMD *cmdp;
 114 {
 115         CC const *ccp;
 116         EX_PRIVATE *exp;
 117         int i;
 118         char *cmd, *p;
 119
 120         /* Initialize the default cscope directories. */
 121         exp = EXP(sp);
 122         if (!F_ISSET(exp, EXP_CSCINIT) && start_cscopes(sp, cmdp))
 123                 return (1);
 124         F_SET(exp, EXP_CSCINIT);
 125
 126         /* Skip leading whitespace. */
 127         for (p = cmdp->argv[0]->bp, i = cmdp->argv[0]->len; i > 0; --i, ++p)
 128                 if (!isspace(*p))
 129                         break;
 130         if (i == 0)
 131                 goto usage;
 132
 133         /* Skip the command to any arguments. */
 134         for (cmd = p; i > 0; --i, ++p)
 135                 if (isspace(*p))
 136                         break;
 137         if (*p != '\0') {
 138                 *p++ = '\0';
 139                 for (; *p && isspace(*p); ++p);
 140         }
 141
 142         if ((ccp = lookup_ccmd(cmd)) == NULL) {
 143 usage:          msgq(sp, M_ERR, "309|Use \"cscope help\" for help");
 144                 return (1);
 145         }
 146
 147         /* Call the underlying function. */
 148         return (ccp->function(sp, cmdp, p));
 149 }
 150
 151 /*
 152  * start_cscopes --
 153  *      Initialize the cscope package.
 154  */
 155 static int
 156 start_cscopes(sp, cmdp)
 157         SCR *sp;
 158         EXCMD *cmdp;
 159 {
 160         size_t blen, len;
 161         char *bp, *cscopes, *p, *t;
 162
 163         /*
 164          * EXTENSION #1:
 165          *
 166          * If the CSCOPE_DIRS environment variable is set, we treat it as a
 167          * list of cscope directories that we're using, similar to the tags
 168          * edit option.
 169          *
 170          * XXX
 171          * This should probably be an edit option, although that implies that
 172          * we start/stop cscope processes periodically, instead of once when
 173          * the editor starts.
 174          */
 175         if ((cscopes = getenv("CSCOPE_DIRS")) == NULL)
 176                 return (0);
 177         len = strlen(cscopes);
 178         GET_SPACE_RET(sp, bp, blen, len);
 179         memcpy(bp, cscopes, len + 1);
 180
 181         for (cscopes = t = bp; (p = strsep(&t, "\t :")) != NULL;)
 182                 if (*p != '\0')
 183                         (void)cscope_add(sp, cmdp, p);
 184
 185         FREE_SPACE(sp, bp, blen);
 186         return (0);
 187 }
 188
 189 /*
 190  * cscope_add --
 191  *      The cscope add command.
 192  */
 193 static int
 194 cscope_add(sp, cmdp, dname)
 195         SCR *sp;
 196         EXCMD *cmdp;
 197         char *dname;
 198 {
 199         struct stat sb;
 200         EX_PRIVATE *exp;
 201         CSC *csc;
 202         size_t len;
 203         int cur_argc;
 204         char *dbname, path[MAXPATHLEN];
 205
 206         exp = EXP(sp);
 207
 208         /*
 209          *  0 additional args: usage.
 210          *  1 additional args: matched a file.
 211          * >1 additional args: object, too many args.
 212          */
 213         cur_argc = cmdp->argc;
 214         if (argv_exp2(sp, cmdp, dname, strlen(dname)))
 215                 return (1);
 216         if (cmdp->argc == cur_argc) {
 217                 (void)csc_help(sp, "add");
 218                 return (1);
 219         }
 220         if (cmdp->argc == cur_argc + 1)
 221                 dname = cmdp->argv[cur_argc]->bp;
 222         else {
 223                 ex_emsg(sp, dname, EXM_FILECOUNT);
 224                 return (1);
 225         }
 226
 227         /*
 228          * The user can specify a specific file (so they can have multiple
 229          * Cscope databases in a single directory) or a directory.  If the
 230          * file doesn't exist, we're done.  If it's a directory, append the
 231          * standard database file name and try again.  Store the directory
 232          * name regardless so that we can use it as a base for searches.
 233          */
 234         if (stat(dname, &sb)) {
 235                 msgq(sp, M_SYSERR, dname);
 236                 return (1);
 237         }
 238         if (S_ISDIR(sb.st_mode)) {
 239                 (void)snprintf(path, sizeof(path),
 240                     "%s/%s", dname, CSCOPE_DBFILE);
 241                 if (stat(path, &sb)) {
 242                         msgq(sp, M_SYSERR, path);
 243                         return (1);
 244                 }
 245                 dbname = CSCOPE_DBFILE;
 246         } else if ((dbname = strrchr(dname, '/')) != NULL)
 247                 *dbname++ = '\0';
 248
 249         /* Allocate a cscope connection structure and initialize its fields. */
 250         len = strlen(dname);
 251         CALLOC_RET(sp, csc, CSC *, 1, sizeof(CSC) + len);
 252         csc->dname = csc->buf;
 253         csc->dlen = len;
 254         memcpy(csc->dname, dname, len);
 255         csc->mtime = sb.st_mtime;
 256
 257         /* Get the search paths for the cscope. */
 258         if (get_paths(sp, csc))
 259                 goto err;
 260
 261         /* Start the cscope process. */
 262         if (run_cscope(sp, csc, dbname))
 263                 goto err;
 264
 265         /*
 266          * Add the cscope connection to the screen's list.  From now on,
 267          * on error, we have to call terminate, which expects the csc to
 268          * be on the chain.
 269          */
 270         LIST_INSERT_HEAD(&exp->cscq, csc, q);
 271
 272         /* Read the initial prompt from the cscope to make sure it's okay. */
 273         if (read_prompt(sp, csc)) {
 274                 terminate(sp, csc, 0);
 275                 return (1);
 276         }
 277
 278         return (0);
 279
 280 err:    free(csc);
 281         return (1);
 282 }
 283
 284 /*
 285  * get_paths --
 286  *      Get the directories to search for the files associated with this
 287  *      cscope database.
 288  */
 289 static int
 290 get_paths(sp, csc)
 291         SCR *sp;
 292         CSC *csc;
 293 {
 294         struct stat sb;
 295         int fd, nentries;
 296         size_t len;
 297         char *p, **pathp, buf[MAXPATHLEN * 2];
 298
 299         /*
 300          * EXTENSION #2:
 301          *
 302          * If there's a cscope directory with a file named CSCOPE_PATHS, it
 303          * contains a colon-separated list of paths in which to search for
 304          * files returned by cscope.
 305          *
 306          * XXX
 307          * These paths are absolute paths, and not relative to the cscope
 308          * directory.  To fix this, rewrite the each path using the cscope
 309          * directory as a prefix.
 310          */
 311         (void)snprintf(buf, sizeof(buf), "%s/%s", csc->dname, CSCOPE_PATHS);
 312         if (stat(buf, &sb) == 0) {
 313                 /* Read in the CSCOPE_PATHS file. */
 314                 len = sb.st_size;
 315                 MALLOC_RET(sp, csc->pbuf, char *, len + 1);
 316                 if ((fd = open(buf, O_RDONLY, 0)) < 0 ||
 317                     read(fd, csc->pbuf, len) != len) {
 318                          msgq_str(sp, M_SYSERR, buf, "%s");
 319                          if (fd >= 0)
 320                                 (void)close(fd);
 321                          return (1);
 322                 }
 323                 (void)close(fd);
 324                 csc->pbuf[len] = '\0';
 325
 326                 /* Count up the entries. */
 327                 for (nentries = 0, p = csc->pbuf; *p != '\0'; ++p)
 328                         if (p[0] == ':' && p[1] != '\0')
 329                                 ++nentries;
 330
 331                 /* Build an array of pointers to the paths. */
 332                 CALLOC_GOTO(sp,
 333                     csc->paths, char **, nentries + 1, sizeof(char **));
 334                 for (pathp = csc->paths, p = strtok(csc->pbuf, ":");
 335                     p != NULL; p = strtok(NULL, ":"))
 336                         *pathp++ = p;
 337                 return (0);
 338         }
 339
 340         /*
 341          * If the CSCOPE_PATHS file doesn't exist, we look for files
 342          * relative to the cscope directory.
 343          */
 344         if ((csc->pbuf = strdup(csc->dname)) == NULL) {
 345                 msgq(sp, M_SYSERR, NULL);
 346                 return (1);
 347         }
 348         CALLOC_GOTO(sp, csc->paths, char **, 2, sizeof(char *));
 349         csc->paths[0] = csc->pbuf;
 350         return (0);
 351
 352 alloc_err:
 353         if (csc->pbuf != NULL) {
 354                 free(csc->pbuf);
 355                 csc->pbuf = NULL;
 356         }
 357         return (1);
 358 }
 359
 360 /*
 361  * run_cscope --
 362  *      Fork off the cscope process.
 363  */
 364 static int
 365 run_cscope(sp, csc, dbname)
 366         SCR *sp;
 367         CSC *csc;
 368         char *dbname;
 369 {
 370         int to_cs[2], from_cs[2];
 371         char cmd[MAXPATHLEN * 2];
 372
 373         /*
 374          * Cscope reads from to_cs[0] and writes to from_cs[1]; vi reads from
 375          * from_cs[0] and writes to to_cs[1].
 376          */
 377         to_cs[0] = to_cs[1] = from_cs[0] = from_cs[0] = -1;
 378         if (pipe(to_cs) < 0 || pipe(from_cs) < 0) {
 379                 msgq(sp, M_SYSERR, "pipe");
 380                 goto err;
 381         }
 382         switch (csc->pid = vfork()) {
 383         case -1:
 384                 msgq(sp, M_SYSERR, "vfork");
 385 err:            if (to_cs[0] != -1)
 386                         (void)close(to_cs[0]);
 387                 if (to_cs[1] != -1)
 388                         (void)close(to_cs[1]);
 389                 if (from_cs[0] != -1)
 390                         (void)close(from_cs[0]);
 391                 if (from_cs[1] != -1)
 392                         (void)close(from_cs[1]);
 393                 return (1);
 394         case 0:                         /* child: run cscope. */
 395                 (void)dup2(to_cs[0], STDIN_FILENO);
 396                 (void)dup2(from_cs[1], STDOUT_FILENO);
 397                 (void)dup2(from_cs[1], STDERR_FILENO);
 398
 399                 /* Close unused file descriptors. */
 400                 (void)close(to_cs[1]);
 401                 (void)close(from_cs[0]);
 402
 403                 /* Run the cscope command. */
 404 #define CSCOPE_CMD_FMT          "cd '%s' && exec cscope -dl -f %s"
 405                 (void)snprintf(cmd, sizeof(cmd),
 406                     CSCOPE_CMD_FMT, csc->dname, dbname);
 407                 (void)execl(_PATH_BSHELL, "sh", "-c", cmd, NULL);
 408                 msgq_str(sp, M_SYSERR, cmd, "execl: %s");
 409                 _exit (127);
 410                 /* NOTREACHED */
 411         default:                        /* parent. */
 412                 /* Close unused file descriptors. */
 413                 (void)close(to_cs[0]);
 414                 (void)close(from_cs[1]);
 415
 416                 /*
 417                  * Save the file descriptors for later duplication, and
 418                  * reopen as streams.
 419                  */
 420                 csc->to_fd = to_cs[1];
 421                 csc->to_fp = fdopen(to_cs[1], "w");
 422                 csc->from_fd = from_cs[0];
 423                 csc->from_fp = fdopen(from_cs[0], "r");
 424                 break;
 425         }
 426         return (0);
 427 }
 428
 429 /*
 430  * cscope_find --
 431  *      The cscope find command.
 432  */
 433 static int
 434 cscope_find(sp, cmdp, pattern)
 435         SCR *sp;
 436         EXCMD *cmdp;
 437         char *pattern;
 438 {
 439         CSC *csc, *csc_next;
 440         EX_PRIVATE *exp;
 441         FREF *frp;
 442         TAGQ *rtqp, *tqp;
 443         TAG *rtp;
 444         recno_t lno;
 445         size_t cno, search;
 446         int force, istmp, matches;
 447
 448         exp = EXP(sp);
 449
 450         /* Check for connections. */
 451         if (exp->cscq.lh_first == NULL) {
 452                 msgq(sp, M_ERR, "310|No cscope connections running");
 453                 return (1);
 454         }
 455
 456         /*
 457          * Allocate all necessary memory before doing anything hard.  If the
 458          * tags stack is empty, we'll need the `local context' TAGQ structure
 459          * later.
 460          */
 461         rtp = NULL;
 462         rtqp = NULL;
 463         if (exp->tq.cqh_first == (void *)&exp->tq) {
 464                 /* Initialize the `local context' tag queue structure. */
 465                 CALLOC_GOTO(sp, rtqp, TAGQ *, 1, sizeof(TAGQ));
 466                 CIRCLEQ_INIT(&rtqp->tagq);
 467
 468                 /* Initialize and link in its tag structure. */
 469                 CALLOC_GOTO(sp, rtp, TAG *, 1, sizeof(TAG));
 470                 CIRCLEQ_INSERT_HEAD(&rtqp->tagq, rtp, q);
 471                 rtqp->current = rtp;
 472         }
 473
 474         /* Create the cscope command. */
 475         if ((tqp = create_cs_cmd(sp, pattern, &search)) == NULL)
 476                 goto err;
 477
 478         /*
 479          * Stick the current context in a convenient place, we'll lose it
 480          * when we switch files.
 481          */
 482         frp = sp->frp;
 483         lno = sp->lno;
 484         cno = sp->cno;
 485         istmp = F_ISSET(sp->frp, FR_TMPFILE) && !F_ISSET(cmdp, E_NEWSCREEN);
 486
 487         /* Search all open connections for a match. */
 488         matches = 0;
 489         for (csc = exp->cscq.lh_first; csc != NULL; csc = csc_next) {
 490                 /* Copy csc->q.lh_next here in case csc is killed. */
 491                 csc_next = csc->q.le_next;
 492
 493                 /*
 494                  * Send the command to the cscope program.  (We skip the
 495                  * first two bytes of the command, because we stored the
 496                  * search cscope command character and a leading space
 497                  * there.)
 498                  */
 499                 (void)fprintf(csc->to_fp, "%d%s\n", search, tqp->tag + 2);
 500                 (void)fflush(csc->to_fp);
 501
 502                 /* Read the output. */
 503                 if (parse(sp, csc, tqp, &matches)) {
 504                         if (rtqp != NULL)
 505                                 free(rtqp);
 506                         tagq_free(sp, tqp);
 507                         return (1);
 508                 }
 509         }
 510
 511         if (matches == 0) {
 512                 msgq(sp, M_INFO, "278|No matches for query");
 513                 return (0);
 514         }
 515
 516         tqp->current = tqp->tagq.cqh_first;
 517
 518         /* Try to switch to the first tag. */
 519         force = FL_ISSET(cmdp->iflags, E_C_FORCE);
 520         if (F_ISSET(cmdp, E_NEWSCREEN)) {
 521                 if (ex_tag_Nswitch(sp, tqp->current, force))
 522                         goto err;
 523
 524                 /* Everything else gets done in the new screen. */
 525                 sp = sp->nextdisp;
 526                 exp = EXP(sp);
 527         } else
 528                 if (ex_tag_nswitch(sp, tqp->current, force))
 529                         goto err;
 530
 531         /*
 532          * If this is the first tag, put a `current location' queue entry
 533          * in place, so we can pop all the way back to the current mark.
 534          * Note, it doesn't point to much of anything, it's a placeholder.
 535          */
 536         if (exp->tq.cqh_first == (void *)&exp->tq) {
 537                 CIRCLEQ_INSERT_HEAD(&exp->tq, rtqp, q);
 538         } else
 539                 rtqp = exp->tq.cqh_first;
 540
 541         /* Link the current TAGQ structure into place. */
 542         CIRCLEQ_INSERT_HEAD(&exp->tq, tqp, q);
 543
 544         (void)cscope_search(sp, tqp, tqp->current);
 545
 546         /*
 547          * Move the current context from the temporary save area into the
 548          * right structure.
 549          *
 550          * If we were in a temporary file, we don't have a context to which
 551          * we can return, so just make it be the same as what we're moving
 552          * to.  It will be a little odd that ^T doesn't change anything, but
 553          * I don't think it's a big deal.
 554          */
 555         if (istmp) {
 556                 rtqp->current->frp = sp->frp;
 557                 rtqp->current->lno = sp->lno;
 558                 rtqp->current->cno = sp->cno;
 559         } else {
 560                 rtqp->current->frp = frp;
 561                 rtqp->current->lno = lno;
 562                 rtqp->current->cno = cno;
 563         }
 564
 565         return (0);
 566
 567 err:
 568 alloc_err:
 569         if (rtqp != NULL)
 570                 free(rtqp);
 571         if (rtp != NULL)
 572                 free(rtp);
 573         return (1);
 574 }
 575
 576 /*
 577  * create_cs_cmd --
 578  *      Build a cscope command, creating and initializing the base TAGQ.
 579  */
 580 static TAGQ *
 581 create_cs_cmd(sp, pattern, searchp)
 582         SCR *sp;
 583         char *pattern;
 584         size_t *searchp;
 585 {
 586         CB *cbp;
 587         TAGQ *tqp;
 588         size_t tlen;
 589         char *p;
 590
 591         /*
 592          * Cscope supports a "change pattern" command which we never use,
 593          * cscope command 5.  Set CSCOPE_QUERIES[5] to " " since the user
 594          * can't pass " " as the first character of pattern.  That way the
 595          * user can't ask for pattern 5 so we don't need any special-case
 596          * code.
 597          */
 598 #define CSCOPE_QUERIES          "sgdct efi"
 599
 600         if (pattern == NULL)
 601                 goto usage;
 602
 603         /* Skip leading blanks, check for command character. */
 604         for (; isblank(pattern[0]); ++pattern);
 605         if (pattern[0] == '\0' || !isblank(pattern[1]))
 606                 goto usage;
 607         for (*searchp = 0, p = CSCOPE_QUERIES;
 608             *p != '\0' && *p != pattern[0]; ++*searchp, ++p);
 609         if (*p == '\0') {
 610                 msgq(sp, M_ERR,
 611                     "311|%s: unknown search type: use one of %s",
 612                     KEY_NAME(sp, pattern[0]), CSCOPE_QUERIES);
 613                 return (NULL);
 614         }
 615
 616         /* Skip <blank> characters to the pattern. */
 617         for (p = pattern + 1; *p != '\0' && isblank(*p); ++p);
 618         if (*p == '\0') {
 619 usage:          (void)csc_help(sp, "find");
 620                 return (NULL);
 621         }
 622
 623         /* The user can specify the contents of a buffer as the pattern. */
 624         cbp = NULL;
 625         if (p[0] == '"' && p[1] != '\0' && p[2] == '\0')
 626                 CBNAME(sp, cbp, p[1]);
 627         if (cbp != NULL) {
 628                 p = cbp->textq.cqh_first->lb;
 629                 tlen = cbp->textq.cqh_first->len;
 630         } else
 631                 tlen = strlen(p);
 632
 633         /* Allocate and initialize the TAGQ structure. */
 634         CALLOC(sp, tqp, TAGQ *, 1, sizeof(TAGQ) + tlen + 3);
 635         if (tqp == NULL)
 636                 return (NULL);
 637         CIRCLEQ_INIT(&tqp->tagq);
 638         tqp->tag = tqp->buf;
 639         tqp->tag[0] = pattern[0];
 640         tqp->tag[1] = ' ';
 641         tqp->tlen = tlen + 2;
 642         memcpy(tqp->tag + 2, p, tlen);
 643         tqp->tag[tlen + 2] = '\0';
 644         F_SET(tqp, TAG_CSCOPE);
 645
 646         return (tqp);
 647 }
 648
 649 /*
 650  * parse --
 651  *      Parse the cscope output.
 652  */
 653 static int
 654 parse(sp, csc, tqp, matchesp)
 655         SCR *sp;
 656         CSC *csc;
 657         TAGQ *tqp;
 658         int *matchesp;
 659 {
 660         TAG *tp;
 661         recno_t slno;
 662         size_t dlen, nlen, slen;
 663         int ch, i, isolder, nlines;
 664         char *dname, *name, *search, *p, *t, dummy[2], buf[2048];
 665
 666         for (;;) {
 667                 if (!fgets(buf, sizeof(buf), csc->from_fp))
 668                         goto io_err;
 669
 670                 /*
 671                  * If the database is out of date, or there's some other
 672                  * problem, cscope will output error messages before the
 673                  * number-of-lines output.  Display/discard any output
 674                  * that doesn't match what we want.
 675                  */
 676 #define CSCOPE_NLINES_FMT       "cscope: %d lines%1[\n]"
 677                 if (sscanf(buf, CSCOPE_NLINES_FMT, &nlines, dummy) == 2)
 678                         break;
 679                 if ((p = strchr(buf, '\n')) != NULL)
 680                         *p = '\0';
 681                 msgq(sp, M_ERR, "%s: \"%s\"", csc->dname, buf);
 682         }
 683
 684         while (nlines--) {
 685                 if (fgets(buf, sizeof(buf), csc->from_fp) == NULL)
 686                         goto io_err;
 687
 688                 /* If the line's too long for the buffer, discard it. */
 689                 if ((p = strchr(buf, '\n')) == NULL) {
 690                         while ((ch = getc(csc->from_fp)) != EOF && ch != '\n');
 691                         continue;
 692                 }
 693                 *p = '\0';
 694
 695                 /*
 696                  * The cscope output is in the following format:
 697                  *
 698                  *      <filename> <context> <line number> <pattern>
 699                  *
 700                  * Figure out how long everything is so we can allocate in one
 701                  * swell foop, but discard anything that looks wrong.
 702                  */
 703                 for (p = buf, i = 0;
 704                     i < 3 && (t = strsep(&p, "\t ")) != NULL; ++i)
 705                         switch (i) {
 706                         case 0:                 /* Filename. */
 707                                 name = t;
 708                                 nlen = strlen(name);
 709                                 break;
 710                         case 1:                 /* Context. */
 711                                 break;
 712                         case 2:                 /* Line number. */
 713                                 slno = (recno_t)atol(t);
 714                                 break;
 715                         }
 716                 if (i != 3 || p == NULL || t == NULL)
 717                         continue;
 718
 719                 /* The rest of the string is the search pattern. */
 720                 search = p;
 721                 slen = strlen(p);
 722
 723                 /* Resolve the file name. */
 724                 csc_file(sp, csc, name, &dname, &dlen, &isolder);
 725
 726                 /*
 727                  * If the file is older than the cscope database, that is,
 728                  * the database was built since the file was last modified,
 729                  * or there wasn't a search string, use the line number.
 730                  */
 731                 if (isolder || strcmp(search, "<unknown>") == 0) {
 732                         search = NULL;
 733                         slen = 0;
 734                 }
 735
 736                 /*
 737                  * Allocate and initialize a tag structure plus the variable
 738                  * length cscope information that follows it.
 739                  */
 740                 CALLOC_RET(sp, tp,
 741                     TAG *, 1, sizeof(TAG) + dlen + 2 + nlen + 1 + slen + 1);
 742                 tp->fname = tp->buf;
 743                 if (dlen != 0) {
 744                         memcpy(tp->fname, dname, dlen);
 745                         tp->fname[dlen] = '/';
 746                         ++dlen;
 747                 }
 748                 memcpy(tp->fname + dlen, name, nlen + 1);
 749                 tp->fnlen = dlen + nlen;
 750                 tp->slno = slno;
 751                 if (slen != 0) {
 752                         tp->search = tp->fname + tp->fnlen + 1;
 753                         memcpy(tp->search, search, (tp->slen = slen) + 1);
 754                 }
 755                 CIRCLEQ_INSERT_TAIL(&tqp->tagq, tp, q);
 756
 757                 ++*matchesp;
 758         }
 759
 760         (void)read_prompt(sp, csc);
 761         return (0);
 762
 763 io_err: if (feof(csc->from_fp))
 764                 errno = EIO;
 765         msgq_str(sp, M_SYSERR, "%s", csc->dname);
 766         terminate(sp, csc, 0);
 767         return (1);
 768 }
 769
 770 /*
 771  * csc_file --
 772  *      Search for the right path to this file.
 773  */
 774 static void
 775 csc_file(sp, csc, name, dirp, dlenp, isolderp)
 776         SCR *sp;
 777         CSC *csc;
 778         char *name, **dirp;
 779         size_t *dlenp;
 780         int *isolderp;
 781 {
 782         struct stat sb;
 783         char **pp, buf[MAXPATHLEN];
 784
 785         /*
 786          * Check for the file in all of the listed paths.  If we don't
 787          * find it, we simply return it unchanged.  We have to do this
 788          * now, even though it's expensive, because if the user changes
 789          * directories, we can't change our minds as to where the file
 790          * lives.
 791          */
 792         for (pp = csc->paths; *pp != NULL; ++pp) {
 793                 (void)snprintf(buf, sizeof(buf), "%s/%s", *pp, name);
 794                 if (stat(buf, &sb) == 0) {
 795                         *dirp = *pp;
 796                         *dlenp = strlen(*pp);
 797                         *isolderp = sb.st_mtime < csc->mtime;
 798                         return;
 799                 }
 800         }
 801         *dlenp = 0;
 802 }
 803
 804 /*
 805  * cscope_help --
 806  *      The cscope help command.
 807  */
 808 static int
 809 cscope_help(sp, cmdp, subcmd)
 810         SCR *sp;
 811         EXCMD *cmdp;
 812         char *subcmd;
 813 {
 814         return (csc_help(sp, subcmd));
 815 }
 816
 817 /*
 818  * csc_help --
 819  *      Display help/usage messages.
 820  */
 821 static int
 822 csc_help(sp, cmd)
 823         SCR *sp;
 824         char *cmd;
 825 {
 826         CC const *ccp;
 827
 828         if (cmd != NULL && *cmd != '\0')
 829                 if ((ccp = lookup_ccmd(cmd)) == NULL) {
 830                         ex_printf(sp,
 831                             "%s doesn't match any cscope command\n", cmd);
 832                         return (1);
 833                 } else {
 834                         ex_printf(sp,
 835                           "Command: %s (%s)\n", ccp->name, ccp->help_msg);
 836                         ex_printf(sp, "  Usage: %s\n", ccp->usage_msg);
 837                         return (0);
 838                 }
 839
 840         ex_printf(sp, "cscope commands:\n");
 841         for (ccp = cscope_cmds; ccp->name != NULL; ++ccp)
 842                 ex_printf(sp, "  %*s: %s\n", 5, ccp->name, ccp->help_msg);
 843         return (0);
 844 }
 845
 846 /*
 847  * cscope_kill --
 848  *      The cscope kill command.
 849  */
 850 static int
 851 cscope_kill(sp, cmdp, cn)
 852         SCR *sp;
 853         EXCMD *cmdp;
 854         char *cn;
 855 {
 856         return (terminate(sp, NULL, atoi(cn)));
 857 }
 858
 859 /*
 860  * terminate --
 861  *      Detach from a cscope process.
 862  */
 863 static int
 864 terminate(sp, csc, n)
 865         SCR *sp;
 866         CSC *csc;
 867         int n;
 868 {
 869         EX_PRIVATE *exp;
 870         int i, pstat;
 871
 872         exp = EXP(sp);
 873
 874         /*
 875          * We either get a csc structure or a number.  If not provided a
 876          * csc structure, find the right one.
 877          */
 878         if (csc == NULL) {
 879                 if (n < 1)
 880                         goto badno;
 881                 for (i = 1, csc = exp->cscq.lh_first;
 882                     csc != NULL; csc = csc->q.le_next, i++)
 883                         if (i == n)
 884                                 break;
 885                 if (csc == NULL) {
 886 badno:                  msgq(sp, M_ERR, "312|%d: no such cscope session", n);
 887                         return (1);
 888                 }
 889         }
 890
 891         /*
 892          * XXX
 893          * Theoretically, we have the only file descriptors to the process,
 894          * so closing them should let it exit gracefully, deleting temporary
 895          * files, etc.  The original vi cscope integration sent the cscope
 896          * connection a SIGTERM signal, so I'm not sure if closing the file
 897          * descriptors is sufficient.
 898          */
 899         if (csc->from_fp != NULL)
 900                 (void)fclose(csc->from_fp);
 901         if (csc->to_fp != NULL)
 902                 (void)fclose(csc->to_fp);
 903         (void)waitpid(csc->pid, &pstat, 0);
 904
 905         /* Discard cscope connection information. */
 906         LIST_REMOVE(csc, q);
 907         if (csc->pbuf != NULL)
 908                 free(csc->pbuf);
 909         if (csc->paths != NULL)
 910                 free(csc->paths);
 911         free(csc);
 912         return (0);
 913 }
 914
 915 /*
 916  * cscope_reset --
 917  *      The cscope reset command.
 918  */
 919 static int
 920 cscope_reset(sp, cmdp, notusedp)
 921         SCR *sp;
 922         EXCMD *cmdp;
 923         char *notusedp;
 924 {
 925         EX_PRIVATE *exp;
 926
 927         for (exp = EXP(sp); exp->cscq.lh_first != NULL;)
 928                 if (cscope_kill(sp, cmdp, "1"))
 929                         return (1);
 930         return (0);
 931 }
 932
 933 /*
 934  * cscope_display --
 935  *      Display current connections.
 936  *
 937  * PUBLIC: int cscope_display __P((SCR *));
 938  */
 939 int
 940 cscope_display(sp)
 941         SCR *sp;
 942 {
 943         EX_PRIVATE *exp;
 944         CSC *csc;
 945         int i;
 946
 947         exp = EXP(sp);
 948         if (exp->cscq.lh_first == NULL) {
 949                 ex_printf(sp, "No cscope connections.\n");
 950                 return (0);
 951         }
 952         for (i = 1,
 953             csc = exp->cscq.lh_first; csc != NULL; ++i, csc = csc->q.le_next)
 954                 ex_printf(sp,
 955                     "%2d %s (process %lu)\n", i, csc->dname, (u_long)csc->pid);
 956         return (0);
 957 }
 958
 959 /*
 960  * cscope_search --
 961  *      Search a file for a cscope entry.
 962  *
 963  * PUBLIC: int cscope_search __P((SCR *, TAGQ *, TAG *));
 964  */
 965 int
 966 cscope_search(sp, tqp, tp)
 967         SCR *sp;
 968         TAGQ *tqp;
 969         TAG *tp;
 970 {
 971         MARK m;
 972
 973         /* If we don't have a search pattern, use the line number. */
 974         if (tp->search == NULL) {
 975                 if (!db_exist(sp, tp->slno)) {
 976                         tag_msg(sp, TAG_BADLNO, tqp->tag);
 977                         return (1);
 978                 }
 979                 m.lno = tp->slno;
 980         } else {
 981                 /*
 982                  * Search for the tag; cheap fallback for C functions
 983                  * if the name is the same but the arguments have changed.
 984                  */
 985                 m.lno = 1;
 986                 m.cno = 0;
 987                 if (f_search(sp, &m, &m,
 988                     tp->search, tp->slen, NULL, SEARCH_CSCOPE | SEARCH_FILE)) {
 989                         tag_msg(sp, TAG_SEARCH, tqp->tag);
 990                         return (1);
 991                 }
 992
 993                 /*
 994                  * !!!
 995                  * Historically, tags set the search direction if it wasn't
 996                  * already set.
 997                  */
 998                 if (sp->searchdir == NOTSET)
 999                         sp->searchdir = FORWARD;
1000         }
1001
1002         /*
1003          * !!!
1004          * Tags move to the first non-blank, NOT the search pattern start.
1005          */
1006         sp->lno = m.lno;
1007         sp->cno = 0;
1008         (void)nonblank(sp, sp->lno, &sp->cno);
1009         return (0);
1010 }
1011
1012
1013 /*
1014  * lookup_ccmd --
1015  *      Return a pointer to the command structure.
1016  */
1017 static CC const *
1018 lookup_ccmd(name)
1019         char *name;
1020 {
1021         CC const *ccp;
1022         size_t len;
1023
1024         len = strlen(name);
1025         for (ccp = cscope_cmds; ccp->name != NULL; ++ccp)
1026                 if (strncmp(name, ccp->name, len) == 0)
1027                         return (ccp);
1028         return (NULL);
1029 }
1030
1031 /*
1032  * read_prompt --
1033  *      Read a prompt from cscope.
1034  */
1035 static int
1036 read_prompt(sp, csc)
1037         SCR *sp;
1038         CSC *csc;
1039 {
1040         int ch;
1041
1042 #define CSCOPE_PROMPT           ">> "
1043         for (;;) {
1044                 while ((ch =
1045                     getc(csc->from_fp)) != EOF && ch != CSCOPE_PROMPT[0]);
1046                 if (ch == EOF) {
1047                         terminate(sp, csc, 0);
1048                         return (1);
1049                 }
1050                 if (getc(csc->from_fp) != CSCOPE_PROMPT[1])
1051                         continue;
1052                 if (getc(csc->from_fp) != CSCOPE_PROMPT[2])
1053                         continue;
1054                 break;
1055         }
1056         return (0);
1057 }