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