2 * Copyright (c) 1994, 1996
3 * Rob Mayoff. All rights reserved.
5 * Keith Bostic. All rights reserved.
7 * See the LICENSE file for redistribution information.
13 static const char sccsid[] = "@(#)ex_cscope.c 10.13 (Berkeley) 9/15/96";
16 #include <sys/param.h>
17 #include <sys/types.h> /* XXX: param.h may not have included types.h */
18 #include <sys/queue.h>
23 #include <bitstring.h>
35 #include "../common/common.h"
36 #include "pathnames.h"
39 #define CSCOPE_DBFILE "cscope.out"
40 #define CSCOPE_PATHS "cscope.tpath"
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
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\
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"
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 *));
73 int (*function) __P((SCR *, EXCMD *, char *));
78 static CC const cscope_cmds[] = {
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" },
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));
106 * Perform an ex cscope.
108 * PUBLIC: int ex_cscope __P((SCR *, EXCMD *));
120 /* Initialize the default cscope directories. */
122 if (!F_ISSET(exp, EXP_CSCINIT) && start_cscopes(sp, cmdp))
124 F_SET(exp, EXP_CSCINIT);
126 /* Skip leading whitespace. */
127 for (p = cmdp->argv[0]->bp, i = cmdp->argv[0]->len; i > 0; --i, ++p)
133 /* Skip the command to any arguments. */
134 for (cmd = p; i > 0; --i, ++p)
139 for (; *p && isspace(*p); ++p);
142 if ((ccp = lookup_ccmd(cmd)) == NULL) {
143 usage: msgq(sp, M_ERR, "309|Use \"cscope help\" for help");
147 /* Call the underlying function. */
148 return (ccp->function(sp, cmdp, p));
153 * Initialize the cscope package.
156 start_cscopes(sp, cmdp)
161 char *bp, *cscopes, *p, *t;
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
171 * This should probably be an edit option, although that implies that
172 * we start/stop cscope processes periodically, instead of once when
175 if ((cscopes = getenv("CSCOPE_DIRS")) == NULL)
177 len = strlen(cscopes);
178 GET_SPACE_RET(sp, bp, blen, len);
179 memcpy(bp, cscopes, len + 1);
181 for (cscopes = t = bp; (p = strsep(&t, "\t :")) != NULL;)
183 (void)cscope_add(sp, cmdp, p);
185 FREE_SPACE(sp, bp, blen);
191 * The cscope add command.
194 cscope_add(sp, cmdp, dname)
204 char *dbname, path[MAXPATHLEN];
209 * 0 additional args: usage.
210 * 1 additional args: matched a file.
211 * >1 additional args: object, too many args.
213 cur_argc = cmdp->argc;
214 if (argv_exp2(sp, cmdp, dname, strlen(dname)))
216 if (cmdp->argc == cur_argc) {
217 (void)csc_help(sp, "add");
220 if (cmdp->argc == cur_argc + 1)
221 dname = cmdp->argv[cur_argc]->bp;
223 ex_emsg(sp, dname, EXM_FILECOUNT);
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.
234 if (stat(dname, &sb)) {
235 msgq(sp, M_SYSERR, dname);
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);
245 dbname = CSCOPE_DBFILE;
246 } else if ((dbname = strrchr(dname, '/')) != NULL)
249 /* Allocate a cscope connection structure and initialize its fields. */
251 CALLOC_RET(sp, csc, CSC *, 1, sizeof(CSC) + len);
252 csc->dname = csc->buf;
254 memcpy(csc->dname, dname, len);
255 csc->mtime = sb.st_mtime;
257 /* Get the search paths for the cscope. */
258 if (get_paths(sp, csc))
261 /* Start the cscope process. */
262 if (run_cscope(sp, csc, dbname))
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
270 LIST_INSERT_HEAD(&exp->cscq, csc, q);
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);
286 * Get the directories to search for the files associated with this
297 char *p, **pathp, buf[MAXPATHLEN * 2];
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.
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.
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. */
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");
324 csc->pbuf[len] = '\0';
326 /* Count up the entries. */
327 for (nentries = 0, p = csc->pbuf; *p != '\0'; ++p)
328 if (p[0] == ':' && p[1] != '\0')
331 /* Build an array of pointers to the paths. */
333 csc->paths, char **, nentries + 1, sizeof(char **));
334 for (pathp = csc->paths, p = strtok(csc->pbuf, ":");
335 p != NULL; p = strtok(NULL, ":"))
341 * If the CSCOPE_PATHS file doesn't exist, we look for files
342 * relative to the cscope directory.
344 if ((csc->pbuf = strdup(csc->dname)) == NULL) {
345 msgq(sp, M_SYSERR, NULL);
348 CALLOC_GOTO(sp, csc->paths, char **, 2, sizeof(char *));
349 csc->paths[0] = csc->pbuf;
353 if (csc->pbuf != NULL) {
362 * Fork off the cscope process.
365 run_cscope(sp, csc, dbname)
370 int to_cs[2], from_cs[2];
371 char cmd[MAXPATHLEN * 2];
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].
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");
382 switch (csc->pid = vfork()) {
384 msgq(sp, M_SYSERR, "vfork");
385 err: if (to_cs[0] != -1)
386 (void)close(to_cs[0]);
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]);
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);
399 /* Close unused file descriptors. */
400 (void)close(to_cs[1]);
401 (void)close(from_cs[0]);
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");
411 default: /* parent. */
412 /* Close unused file descriptors. */
413 (void)close(to_cs[0]);
414 (void)close(from_cs[1]);
417 * Save the file descriptors for later duplication, and
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");
431 * The cscope find command.
434 cscope_find(sp, cmdp, pattern)
446 int force, istmp, matches;
450 /* Check for connections. */
451 if (exp->cscq.lh_first == NULL) {
452 msgq(sp, M_ERR, "310|No cscope connections running");
457 * Allocate all necessary memory before doing anything hard. If the
458 * tags stack is empty, we'll need the `local context' TAGQ structure
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);
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);
474 /* Create the cscope command. */
475 if ((tqp = create_cs_cmd(sp, pattern, &search)) == NULL)
479 * Stick the current context in a convenient place, we'll lose it
480 * when we switch files.
485 istmp = F_ISSET(sp->frp, FR_TMPFILE) && !F_ISSET(cmdp, E_NEWSCREEN);
487 /* Search all open connections for a match. */
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;
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
499 (void)fprintf(csc->to_fp, "%d%s\n", search, tqp->tag + 2);
500 (void)fflush(csc->to_fp);
502 /* Read the output. */
503 if (parse(sp, csc, tqp, &matches)) {
512 msgq(sp, M_INFO, "278|No matches for query");
516 tqp->current = tqp->tagq.cqh_first;
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))
524 /* Everything else gets done in the new screen. */
528 if (ex_tag_nswitch(sp, tqp->current, force))
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.
536 if (exp->tq.cqh_first == (void *)&exp->tq) {
537 CIRCLEQ_INSERT_HEAD(&exp->tq, rtqp, q);
539 rtqp = exp->tq.cqh_first;
541 /* Link the current TAGQ structure into place. */
542 CIRCLEQ_INSERT_HEAD(&exp->tq, tqp, q);
544 (void)cscope_search(sp, tqp, tqp->current);
547 * Move the current context from the temporary save area into the
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.
556 rtqp->current->frp = sp->frp;
557 rtqp->current->lno = sp->lno;
558 rtqp->current->cno = sp->cno;
560 rtqp->current->frp = frp;
561 rtqp->current->lno = lno;
562 rtqp->current->cno = cno;
578 * Build a cscope command, creating and initializing the base TAGQ.
581 create_cs_cmd(sp, pattern, searchp)
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
598 #define CSCOPE_QUERIES "sgdct efi"
603 /* Skip leading blanks, check for command character. */
604 for (; isblank(pattern[0]); ++pattern);
605 if (pattern[0] == '\0' || !isblank(pattern[1]))
607 for (*searchp = 0, p = CSCOPE_QUERIES;
608 *p != '\0' && *p != pattern[0]; ++*searchp, ++p);
611 "311|%s: unknown search type: use one of %s",
612 KEY_NAME(sp, pattern[0]), CSCOPE_QUERIES);
616 /* Skip <blank> characters to the pattern. */
617 for (p = pattern + 1; *p != '\0' && isblank(*p); ++p);
619 usage: (void)csc_help(sp, "find");
623 /* The user can specify the contents of a buffer as the pattern. */
625 if (p[0] == '"' && p[1] != '\0' && p[2] == '\0')
626 CBNAME(sp, cbp, p[1]);
628 p = cbp->textq.cqh_first->lb;
629 tlen = cbp->textq.cqh_first->len;
633 /* Allocate and initialize the TAGQ structure. */
634 CALLOC(sp, tqp, TAGQ *, 1, sizeof(TAGQ) + tlen + 3);
637 CIRCLEQ_INIT(&tqp->tagq);
639 tqp->tag[0] = pattern[0];
641 tqp->tlen = tlen + 2;
642 memcpy(tqp->tag + 2, p, tlen);
643 tqp->tag[tlen + 2] = '\0';
644 F_SET(tqp, TAG_CSCOPE);
651 * Parse the cscope output.
654 parse(sp, csc, tqp, matchesp)
662 size_t dlen, nlen, slen;
663 int ch, i, isolder, nlines;
664 char *dname, *name, *search, *p, *t, dummy[2], buf[2048];
667 if (!fgets(buf, sizeof(buf), csc->from_fp))
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.
676 #define CSCOPE_NLINES_FMT "cscope: %d lines%1[\n]"
677 if (sscanf(buf, CSCOPE_NLINES_FMT, &nlines, dummy) == 2)
679 if ((p = strchr(buf, '\n')) != NULL)
681 msgq(sp, M_ERR, "%s: \"%s\"", csc->dname, buf);
685 if (fgets(buf, sizeof(buf), csc->from_fp) == NULL)
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');
696 * The cscope output is in the following format:
698 * <filename> <context> <line number> <pattern>
700 * Figure out how long everything is so we can allocate in one
701 * swell foop, but discard anything that looks wrong.
704 i < 3 && (t = strsep(&p, "\t ")) != NULL; ++i)
706 case 0: /* Filename. */
710 case 1: /* Context. */
712 case 2: /* Line number. */
713 slno = (recno_t)atol(t);
716 if (i != 3 || p == NULL || t == NULL)
719 /* The rest of the string is the search pattern. */
723 /* Resolve the file name. */
724 csc_file(sp, csc, name, &dname, &dlen, &isolder);
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.
731 if (isolder || strcmp(search, "<unknown>") == 0) {
737 * Allocate and initialize a tag structure plus the variable
738 * length cscope information that follows it.
741 TAG *, 1, sizeof(TAG) + dlen + 2 + nlen + 1 + slen + 1);
744 memcpy(tp->fname, dname, dlen);
745 tp->fname[dlen] = '/';
748 memcpy(tp->fname + dlen, name, nlen + 1);
749 tp->fnlen = dlen + nlen;
752 tp->search = tp->fname + tp->fnlen + 1;
753 memcpy(tp->search, search, (tp->slen = slen) + 1);
755 CIRCLEQ_INSERT_TAIL(&tqp->tagq, tp, q);
760 (void)read_prompt(sp, csc);
763 io_err: if (feof(csc->from_fp))
765 msgq_str(sp, M_SYSERR, "%s", csc->dname);
766 terminate(sp, csc, 0);
772 * Search for the right path to this file.
775 csc_file(sp, csc, name, dirp, dlenp, isolderp)
783 char **pp, buf[MAXPATHLEN];
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
792 for (pp = csc->paths; *pp != NULL; ++pp) {
793 (void)snprintf(buf, sizeof(buf), "%s/%s", *pp, name);
794 if (stat(buf, &sb) == 0) {
796 *dlenp = strlen(*pp);
797 *isolderp = sb.st_mtime < csc->mtime;
806 * The cscope help command.
809 cscope_help(sp, cmdp, subcmd)
814 return (csc_help(sp, subcmd));
819 * Display help/usage messages.
828 if (cmd != NULL && *cmd != '\0')
829 if ((ccp = lookup_ccmd(cmd)) == NULL) {
831 "%s doesn't match any cscope command\n", cmd);
835 "Command: %s (%s)\n", ccp->name, ccp->help_msg);
836 ex_printf(sp, " Usage: %s\n", ccp->usage_msg);
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);
848 * The cscope kill command.
851 cscope_kill(sp, cmdp, cn)
856 return (terminate(sp, NULL, atoi(cn)));
861 * Detach from a cscope process.
864 terminate(sp, csc, n)
875 * We either get a csc structure or a number. If not provided a
876 * csc structure, find the right one.
881 for (i = 1, csc = exp->cscq.lh_first;
882 csc != NULL; csc = csc->q.le_next, i++)
886 badno: msgq(sp, M_ERR, "312|%d: no such cscope session", n);
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.
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);
905 /* Discard cscope connection information. */
907 if (csc->pbuf != NULL)
909 if (csc->paths != NULL)
917 * The cscope reset command.
920 cscope_reset(sp, cmdp, notusedp)
927 for (exp = EXP(sp); exp->cscq.lh_first != NULL;)
928 if (cscope_kill(sp, cmdp, "1"))
935 * Display current connections.
937 * PUBLIC: int cscope_display __P((SCR *));
948 if (exp->cscq.lh_first == NULL) {
949 ex_printf(sp, "No cscope connections.\n");
953 csc = exp->cscq.lh_first; csc != NULL; ++i, csc = csc->q.le_next)
955 "%2d %s (process %lu)\n", i, csc->dname, (u_long)csc->pid);
961 * Search a file for a cscope entry.
963 * PUBLIC: int cscope_search __P((SCR *, TAGQ *, TAG *));
966 cscope_search(sp, tqp, tp)
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);
982 * Search for the tag; cheap fallback for C functions
983 * if the name is the same but the arguments have changed.
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);
995 * Historically, tags set the search direction if it wasn't
998 if (sp->searchdir == NOTSET)
999 sp->searchdir = FORWARD;
1004 * Tags move to the first non-blank, NOT the search pattern start.
1008 (void)nonblank(sp, sp->lno, &sp->cno);
1015 * Return a pointer to the command structure.
1025 for (ccp = cscope_cmds; ccp->name != NULL; ++ccp)
1026 if (strncmp(name, ccp->name, len) == 0)
1033 * Read a prompt from cscope.
1036 read_prompt(sp, csc)
1042 #define CSCOPE_PROMPT ">> "
1045 getc(csc->from_fp)) != EOF && ch != CSCOPE_PROMPT[0]);
1047 terminate(sp, csc, 0);
1050 if (getc(csc->from_fp) != CSCOPE_PROMPT[1])
1052 if (getc(csc->from_fp) != CSCOPE_PROMPT[2])