|
7
|
1 /* vi:set ts=8 sts=4 sw=4:
|
|
|
2 *
|
|
|
3 * CSCOPE support for Vim added by Andy Kahn <kahn@zk3.dec.com>
|
|
148
|
4 * Ported to Win32 by Sergey Khorev <sergey.khorev@gmail.com>
|
|
7
|
5 *
|
|
|
6 * The basic idea/structure of cscope for Vim was borrowed from Nvi. There
|
|
|
7 * might be a few lines of code that look similar to what Nvi has.
|
|
|
8 *
|
|
|
9 * See README.txt for an overview of the Vim source code.
|
|
|
10 */
|
|
|
11
|
|
|
12 #include "vim.h"
|
|
|
13
|
|
|
14 #if defined(FEAT_CSCOPE) || defined(PROTO)
|
|
|
15
|
|
|
16 #include <string.h>
|
|
|
17 #include <errno.h>
|
|
|
18 #include <assert.h>
|
|
|
19 #include <sys/types.h>
|
|
|
20 #include <sys/stat.h>
|
|
|
21 #if defined(UNIX)
|
|
|
22 # include <sys/wait.h>
|
|
|
23 #else
|
|
|
24 /* not UNIX, must be WIN32 */
|
|
|
25 # include <io.h>
|
|
|
26 # include <fcntl.h>
|
|
|
27 # include <process.h>
|
|
|
28 # define STDIN_FILENO 0
|
|
|
29 # define STDOUT_FILENO 1
|
|
|
30 # define STDERR_FILENO 2
|
|
|
31 # define pipe(fds) _pipe(fds, 256, O_TEXT|O_NOINHERIT)
|
|
|
32 #endif
|
|
|
33 #include "if_cscope.h"
|
|
|
34
|
|
|
35 static void cs_usage_msg __ARGS((csid_e x));
|
|
|
36 static int cs_add __ARGS((exarg_T *eap));
|
|
|
37 static void cs_stat_emsg __ARGS((char *fname));
|
|
|
38 static int cs_add_common __ARGS((char *, char *, char *));
|
|
|
39 static int cs_check_for_connections __ARGS((void));
|
|
|
40 static int cs_check_for_tags __ARGS((void));
|
|
|
41 static int cs_cnt_connections __ARGS((void));
|
|
|
42 static void cs_reading_emsg __ARGS((int idx));
|
|
|
43 static int cs_cnt_matches __ARGS((int idx));
|
|
|
44 static char * cs_create_cmd __ARGS((char *csoption, char *pattern));
|
|
|
45 static int cs_create_connection __ARGS((int i));
|
|
|
46 static void do_cscope_general __ARGS((exarg_T *eap, int make_split));
|
|
636
|
47 #ifdef FEAT_QUICKFIX
|
|
7
|
48 static void cs_file_results __ARGS((FILE *, int *));
|
|
636
|
49 #endif
|
|
7
|
50 static void cs_fill_results __ARGS((char *, int , int *, char ***,
|
|
|
51 char ***, int *));
|
|
|
52 static int cs_find __ARGS((exarg_T *eap));
|
|
665
|
53 static int cs_find_common __ARGS((char *opt, char *pat, int, int, int));
|
|
7
|
54 static int cs_help __ARGS((exarg_T *eap));
|
|
|
55 static void cs_init __ARGS((void));
|
|
|
56 static void clear_csinfo __ARGS((int i));
|
|
|
57 static int cs_insert_filelist __ARGS((char *, char *, char *,
|
|
|
58 struct stat *));
|
|
|
59 static int cs_kill __ARGS((exarg_T *eap));
|
|
|
60 static void cs_kill_execute __ARGS((int, char *));
|
|
|
61 static cscmd_T * cs_lookup_cmd __ARGS((exarg_T *eap));
|
|
|
62 static char * cs_make_vim_style_matches __ARGS((char *, char *,
|
|
|
63 char *, char *));
|
|
|
64 static char * cs_manage_matches __ARGS((char **, char **, int, mcmd_e));
|
|
|
65 static char * cs_parse_results __ARGS((int cnumber, char *buf, int bufsize, char **context, char **linenumber, char **search));
|
|
|
66 static char * cs_pathcomponents __ARGS((char *path));
|
|
|
67 static void cs_print_tags_priv __ARGS((char **, char **, int));
|
|
|
68 static int cs_read_prompt __ARGS((int ));
|
|
|
69 static void cs_release_csp __ARGS((int, int freefnpp));
|
|
|
70 static int cs_reset __ARGS((exarg_T *eap));
|
|
|
71 static char * cs_resolve_file __ARGS((int, char *));
|
|
|
72 static int cs_show __ARGS((exarg_T *eap));
|
|
|
73
|
|
|
74
|
|
|
75 static csinfo_T csinfo[CSCOPE_MAX_CONNECTIONS];
|
|
|
76 static cscmd_T cs_cmds[] =
|
|
|
77 {
|
|
|
78 { "add", cs_add,
|
|
|
79 N_("Add a new database"), "add file|dir [pre-path] [flags]", 0 },
|
|
|
80 { "find", cs_find,
|
|
|
81 N_("Query for a pattern"), FIND_USAGE, 1 },
|
|
|
82 { "help", cs_help,
|
|
|
83 N_("Show this message"), "help", 0 },
|
|
|
84 { "kill", cs_kill,
|
|
|
85 N_("Kill a connection"), "kill #", 0 },
|
|
|
86 { "reset", cs_reset,
|
|
|
87 N_("Reinit all connections"), "reset", 0 },
|
|
|
88 { "show", cs_show,
|
|
|
89 N_("Show connections"), "show", 0 },
|
|
|
90 { NULL }
|
|
|
91 };
|
|
|
92
|
|
|
93 static void
|
|
|
94 cs_usage_msg(x)
|
|
|
95 csid_e x;
|
|
|
96 {
|
|
|
97 (void)EMSG2(_("E560: Usage: cs[cope] %s"), cs_cmds[(int)x].usage);
|
|
|
98 }
|
|
|
99
|
|
|
100 /*
|
|
|
101 * PRIVATE: do_cscope_general
|
|
|
102 *
|
|
|
103 * find the command, print help if invalid, and the then call the
|
|
|
104 * corresponding command function,
|
|
|
105 * called from do_cscope and do_scscope
|
|
|
106 */
|
|
|
107 static void
|
|
|
108 do_cscope_general(eap, make_split)
|
|
|
109 exarg_T *eap;
|
|
|
110 int make_split; /* whether to split window */
|
|
|
111 {
|
|
|
112 cscmd_T *cmdp;
|
|
|
113
|
|
|
114 cs_init();
|
|
|
115 if ((cmdp = cs_lookup_cmd(eap)) == NULL)
|
|
|
116 {
|
|
|
117 cs_help(eap);
|
|
|
118 return;
|
|
|
119 }
|
|
|
120
|
|
|
121 #ifdef FEAT_WINDOWS
|
|
|
122 if (make_split)
|
|
|
123 {
|
|
|
124 if (!cmdp->cansplit)
|
|
|
125 {
|
|
|
126 (void)MSG_PUTS(_("This cscope command does not support splitting the window.\n"));
|
|
|
127 return;
|
|
|
128 }
|
|
|
129 postponed_split = -1;
|
|
|
130 postponed_split_flags = cmdmod.split;
|
|
|
131 }
|
|
|
132 #endif
|
|
|
133
|
|
|
134 cmdp->func(eap);
|
|
|
135
|
|
|
136 #ifdef FEAT_WINDOWS
|
|
|
137 postponed_split_flags = 0;
|
|
|
138 #endif
|
|
|
139 }
|
|
|
140
|
|
|
141 /*
|
|
|
142 * PUBLIC: do_cscope
|
|
|
143 */
|
|
|
144 void
|
|
|
145 do_cscope(eap)
|
|
|
146 exarg_T *eap;
|
|
|
147 {
|
|
|
148 do_cscope_general(eap, FALSE);
|
|
|
149 }
|
|
|
150
|
|
|
151 /*
|
|
|
152 * PUBLIC: do_scscope
|
|
|
153 *
|
|
|
154 * same as do_cscope, but splits window, too.
|
|
|
155 */
|
|
|
156 void
|
|
|
157 do_scscope(eap)
|
|
|
158 exarg_T *eap;
|
|
|
159 {
|
|
|
160 do_cscope_general(eap, TRUE);
|
|
|
161 }
|
|
|
162
|
|
|
163 /*
|
|
|
164 * PUBLIC: do_cstag
|
|
|
165 *
|
|
|
166 */
|
|
|
167 void
|
|
|
168 do_cstag(eap)
|
|
|
169 exarg_T *eap;
|
|
|
170 {
|
|
|
171 int ret = FALSE;
|
|
|
172
|
|
|
173 cs_init();
|
|
|
174
|
|
|
175 if (eap->arg == NULL || strlen((const char *)(eap->arg)) == 0)
|
|
|
176 {
|
|
|
177 (void)EMSG(_("E562: Usage: cstag <ident>"));
|
|
|
178 return;
|
|
|
179 }
|
|
|
180
|
|
|
181 switch (p_csto)
|
|
|
182 {
|
|
|
183 case 0 :
|
|
|
184 if (cs_check_for_connections())
|
|
|
185 {
|
|
665
|
186 ret = cs_find_common("g", (char *)(eap->arg), eap->forceit, FALSE,
|
|
|
187 FALSE);
|
|
7
|
188 if (ret == FALSE)
|
|
|
189 {
|
|
|
190 cs_free_tags();
|
|
|
191 if (msg_col)
|
|
|
192 msg_putchar('\n');
|
|
|
193
|
|
|
194 if (cs_check_for_tags())
|
|
|
195 ret = do_tag(eap->arg, DT_JUMP, 0, eap->forceit, FALSE);
|
|
|
196 }
|
|
|
197 }
|
|
|
198 else if (cs_check_for_tags())
|
|
|
199 {
|
|
|
200 ret = do_tag(eap->arg, DT_JUMP, 0, eap->forceit, FALSE);
|
|
|
201 }
|
|
|
202 break;
|
|
|
203 case 1 :
|
|
|
204 if (cs_check_for_tags())
|
|
|
205 {
|
|
|
206 ret = do_tag(eap->arg, DT_JUMP, 0, eap->forceit, FALSE);
|
|
|
207 if (ret == FALSE)
|
|
|
208 {
|
|
|
209 if (msg_col)
|
|
|
210 msg_putchar('\n');
|
|
|
211
|
|
|
212 if (cs_check_for_connections())
|
|
|
213 {
|
|
|
214 ret = cs_find_common("g", (char *)(eap->arg), eap->forceit,
|
|
665
|
215 FALSE, FALSE);
|
|
7
|
216 if (ret == FALSE)
|
|
|
217 cs_free_tags();
|
|
|
218 }
|
|
|
219 }
|
|
|
220 }
|
|
|
221 else if (cs_check_for_connections())
|
|
|
222 {
|
|
665
|
223 ret = cs_find_common("g", (char *)(eap->arg), eap->forceit, FALSE,
|
|
|
224 FALSE);
|
|
7
|
225 if (ret == FALSE)
|
|
|
226 cs_free_tags();
|
|
|
227 }
|
|
|
228 break;
|
|
|
229 default :
|
|
|
230 break;
|
|
|
231 }
|
|
|
232
|
|
|
233 if (!ret)
|
|
|
234 {
|
|
|
235 (void)EMSG(_("E257: cstag: tag not found"));
|
|
|
236 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
|
|
|
237 g_do_tagpreview = 0;
|
|
|
238 #endif
|
|
|
239 }
|
|
|
240
|
|
|
241 } /* do_cscope */
|
|
|
242
|
|
|
243
|
|
|
244 /*
|
|
|
245 * PUBLIC: cs_find
|
|
|
246 *
|
|
|
247 * this simulates a vim_fgets(), but for cscope, returns the next line
|
|
|
248 * from the cscope output. should only be called from find_tags()
|
|
|
249 *
|
|
|
250 * returns TRUE if eof, FALSE otherwise
|
|
|
251 */
|
|
|
252 int
|
|
|
253 cs_fgets(buf, size)
|
|
|
254 char_u *buf;
|
|
|
255 int size;
|
|
|
256 {
|
|
|
257 char *p;
|
|
|
258
|
|
|
259 if ((p = cs_manage_matches(NULL, NULL, -1, Get)) == NULL)
|
|
|
260 return TRUE;
|
|
|
261
|
|
|
262 if ((int)strlen(p) > size)
|
|
|
263 {
|
|
|
264 strncpy((char *)buf, p, size - 1);
|
|
|
265 buf[size] = '\0';
|
|
|
266 }
|
|
|
267 else
|
|
|
268 (void)strcpy((char *)buf, p);
|
|
|
269
|
|
|
270 return FALSE;
|
|
|
271 } /* cs_fgets */
|
|
|
272
|
|
|
273
|
|
|
274 /*
|
|
|
275 * PUBLIC: cs_free_tags
|
|
|
276 *
|
|
|
277 * called only from do_tag(), when popping the tag stack
|
|
|
278 */
|
|
|
279 void
|
|
|
280 cs_free_tags()
|
|
|
281 {
|
|
|
282 cs_manage_matches(NULL, NULL, -1, Free);
|
|
|
283 }
|
|
|
284
|
|
|
285
|
|
|
286 /*
|
|
|
287 * PUBLIC: cs_print_tags
|
|
|
288 *
|
|
|
289 * called from do_tag()
|
|
|
290 */
|
|
|
291 void
|
|
|
292 cs_print_tags()
|
|
|
293 {
|
|
|
294 cs_manage_matches(NULL, NULL, -1, Print);
|
|
|
295 }
|
|
|
296
|
|
|
297
|
|
|
298 /*
|
|
|
299 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
|
|
|
300 *
|
|
|
301 * Checks for the existence of a |cscope| connection. If no
|
|
|
302 * parameters are specified, then the function returns:
|
|
|
303 *
|
|
|
304 * 0, if cscope was not available (not compiled in), or if there
|
|
|
305 * are no cscope connections; or
|
|
|
306 * 1, if there is at least one cscope connection.
|
|
|
307 *
|
|
|
308 * If parameters are specified, then the value of {num}
|
|
|
309 * determines how existence of a cscope connection is checked:
|
|
|
310 *
|
|
|
311 * {num} Description of existence check
|
|
|
312 * ----- ------------------------------
|
|
|
313 * 0 Same as no parameters (e.g., "cscope_connection()").
|
|
|
314 * 1 Ignore {prepend}, and use partial string matches for
|
|
|
315 * {dbpath}.
|
|
|
316 * 2 Ignore {prepend}, and use exact string matches for
|
|
|
317 * {dbpath}.
|
|
|
318 * 3 Use {prepend}, use partial string matches for both
|
|
|
319 * {dbpath} and {prepend}.
|
|
|
320 * 4 Use {prepend}, use exact string matches for both
|
|
|
321 * {dbpath} and {prepend}.
|
|
|
322 *
|
|
|
323 * Note: All string comparisons are case sensitive!
|
|
|
324 */
|
|
|
325 #if defined(FEAT_EVAL) || defined(PROTO)
|
|
|
326 int
|
|
|
327 cs_connection(num, dbpath, ppath)
|
|
|
328 int num;
|
|
|
329 char_u *dbpath;
|
|
|
330 char_u *ppath;
|
|
|
331 {
|
|
|
332 int i;
|
|
|
333
|
|
|
334 if (num < 0 || num > 4 || (num > 0 && !dbpath))
|
|
|
335 return FALSE;
|
|
|
336
|
|
|
337 for (i = 0; i < CSCOPE_MAX_CONNECTIONS; i++)
|
|
|
338 {
|
|
|
339 if (!csinfo[i].fname)
|
|
|
340 continue;
|
|
|
341
|
|
|
342 if (num == 0)
|
|
|
343 return TRUE;
|
|
|
344
|
|
|
345 switch (num)
|
|
|
346 {
|
|
|
347 case 1:
|
|
|
348 if (strstr(csinfo[i].fname, (char *)dbpath))
|
|
|
349 return TRUE;
|
|
|
350 break;
|
|
|
351 case 2:
|
|
|
352 if (strcmp(csinfo[i].fname, (char *)dbpath) == 0)
|
|
|
353 return TRUE;
|
|
|
354 break;
|
|
|
355 case 3:
|
|
|
356 if (strstr(csinfo[i].fname, (char *)dbpath)
|
|
|
357 && ((!ppath && !csinfo[i].ppath)
|
|
|
358 || (ppath
|
|
|
359 && csinfo[i].ppath
|
|
|
360 && strstr(csinfo[i].ppath, (char *)ppath))))
|
|
|
361 return TRUE;
|
|
|
362 break;
|
|
|
363 case 4:
|
|
|
364 if ((strcmp(csinfo[i].fname, (char *)dbpath) == 0)
|
|
|
365 && ((!ppath && !csinfo[i].ppath)
|
|
|
366 || (ppath
|
|
|
367 && csinfo[i].ppath
|
|
|
368 && (strcmp(csinfo[i].ppath, (char *)ppath) == 0))))
|
|
|
369 return TRUE;
|
|
|
370 break;
|
|
|
371 }
|
|
|
372 }
|
|
|
373
|
|
|
374 return FALSE;
|
|
|
375 } /* cs_connection */
|
|
|
376 #endif
|
|
|
377
|
|
|
378
|
|
|
379 /*
|
|
|
380 * PRIVATE functions
|
|
|
381 ****************************************************************************/
|
|
|
382
|
|
|
383 /*
|
|
|
384 * PRIVATE: cs_add
|
|
|
385 *
|
|
|
386 * add cscope database or a directory name (to look for cscope.out)
|
|
|
387 * the the cscope connection list
|
|
|
388 *
|
|
|
389 * MAXPATHL 256
|
|
|
390 */
|
|
|
391 /* ARGSUSED */
|
|
|
392 static int
|
|
|
393 cs_add(eap)
|
|
|
394 exarg_T *eap;
|
|
|
395 {
|
|
|
396 char *fname, *ppath, *flags = NULL;
|
|
|
397
|
|
|
398 if ((fname = strtok((char *)NULL, (const char *)" ")) == NULL)
|
|
|
399 {
|
|
|
400 cs_usage_msg(Add);
|
|
|
401 return CSCOPE_FAILURE;
|
|
|
402 }
|
|
|
403 if ((ppath = strtok((char *)NULL, (const char *)" ")) != NULL)
|
|
|
404 flags = strtok((char *)NULL, (const char *)" ");
|
|
|
405
|
|
|
406 return cs_add_common(fname, ppath, flags);
|
|
|
407 }
|
|
|
408
|
|
|
409 static void
|
|
|
410 cs_stat_emsg(fname)
|
|
|
411 char *fname;
|
|
|
412 {
|
|
|
413 char *stat_emsg = _("E563: stat(%s) error: %d");
|
|
|
414 char *buf = (char *)alloc((unsigned)strlen(stat_emsg) + MAXPATHL + 10);
|
|
|
415
|
|
|
416 if (buf != NULL)
|
|
|
417 {
|
|
|
418 (void)sprintf(buf, stat_emsg, fname, errno);
|
|
|
419 (void)EMSG(buf);
|
|
|
420 vim_free(buf);
|
|
|
421 }
|
|
|
422 else
|
|
|
423 (void)EMSG(_("E563: stat error"));
|
|
|
424 }
|
|
|
425
|
|
|
426
|
|
|
427 /*
|
|
|
428 * PRIVATE: cs_add_common
|
|
|
429 *
|
|
|
430 * the common routine to add a new cscope connection. called by
|
|
|
431 * cs_add() and cs_reset(). i really don't like to do this, but this
|
|
|
432 * routine uses a number of goto statements.
|
|
|
433 */
|
|
|
434 static int
|
|
|
435 cs_add_common(arg1, arg2, flags)
|
|
|
436 char *arg1; /* filename - may contain environment variables */
|
|
|
437 char *arg2; /* prepend path - may contain environment variables */
|
|
|
438 char *flags;
|
|
|
439 {
|
|
|
440 struct stat statbuf;
|
|
12
|
441 int ret;
|
|
|
442 char *fname = NULL;
|
|
|
443 char *fname2 = NULL;
|
|
|
444 char *ppath = NULL;
|
|
|
445 int i;
|
|
7
|
446
|
|
|
447 /* get the filename (arg1), expand it, and try to stat it */
|
|
12
|
448 if ((fname = (char *)alloc(MAXPATHL + 1)) == NULL)
|
|
7
|
449 goto add_err;
|
|
|
450
|
|
|
451 expand_env((char_u *)arg1, (char_u *)fname, MAXPATHL);
|
|
|
452 ret = stat(fname, &statbuf);
|
|
|
453 if (ret < 0)
|
|
|
454 {
|
|
|
455 staterr:
|
|
|
456 if (p_csverbose)
|
|
|
457 cs_stat_emsg(fname);
|
|
|
458 goto add_err;
|
|
|
459 }
|
|
|
460
|
|
|
461 /* get the prepend path (arg2), expand it, and try to stat it */
|
|
|
462 if (arg2 != NULL)
|
|
|
463 {
|
|
|
464 struct stat statbuf2;
|
|
|
465
|
|
12
|
466 if ((ppath = (char *)alloc(MAXPATHL + 1)) == NULL)
|
|
7
|
467 goto add_err;
|
|
|
468
|
|
|
469 expand_env((char_u *)arg2, (char_u *)ppath, MAXPATHL);
|
|
|
470 ret = stat(ppath, &statbuf2);
|
|
|
471 if (ret < 0)
|
|
|
472 goto staterr;
|
|
|
473 }
|
|
|
474
|
|
|
475 /* if filename is a directory, append the cscope database name to it */
|
|
|
476 if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
|
|
|
477 {
|
|
|
478 fname2 = (char *)alloc(strlen(CSCOPE_DBFILE) + strlen(fname) + 2);
|
|
|
479 if (fname2 == NULL)
|
|
|
480 goto add_err;
|
|
|
481
|
|
|
482 while (fname[strlen(fname)-1] == '/'
|
|
|
483 #ifdef WIN32
|
|
|
484 || fname[strlen(fname)-1] == '\\'
|
|
|
485 #endif
|
|
|
486 )
|
|
|
487 {
|
|
|
488 fname[strlen(fname)-1] = '\0';
|
|
|
489 if (strlen(fname) == 0)
|
|
|
490 break;
|
|
|
491 }
|
|
|
492 if (fname[0] == '\0')
|
|
|
493 (void)sprintf(fname2, "/%s", CSCOPE_DBFILE);
|
|
|
494 else
|
|
|
495 (void)sprintf(fname2, "%s/%s", fname, CSCOPE_DBFILE);
|
|
|
496
|
|
|
497 ret = stat(fname2, &statbuf);
|
|
|
498 if (ret < 0)
|
|
|
499 {
|
|
|
500 if (p_csverbose)
|
|
|
501 cs_stat_emsg(fname2);
|
|
|
502 goto add_err;
|
|
|
503 }
|
|
|
504
|
|
|
505 i = cs_insert_filelist(fname2, ppath, flags, &statbuf);
|
|
|
506 }
|
|
|
507 #if defined(UNIX)
|
|
|
508 else if (S_ISREG(statbuf.st_mode) || S_ISLNK(statbuf.st_mode))
|
|
|
509 #else
|
|
|
510 /* substitute define S_ISREG from os_unix.h */
|
|
|
511 else if (((statbuf.st_mode) & S_IFMT) == S_IFREG)
|
|
|
512 #endif
|
|
|
513 {
|
|
|
514 i = cs_insert_filelist(fname, ppath, flags, &statbuf);
|
|
|
515 }
|
|
|
516 else
|
|
|
517 {
|
|
|
518 if (p_csverbose)
|
|
|
519 (void)EMSG2(
|
|
|
520 _("E564: %s is not a directory or a valid cscope database"),
|
|
|
521 fname);
|
|
|
522 goto add_err;
|
|
|
523 }
|
|
|
524
|
|
|
525 if (i != -1)
|
|
|
526 {
|
|
|
527 if (cs_create_connection(i) == CSCOPE_FAILURE
|
|
|
528 || cs_read_prompt(i) == CSCOPE_FAILURE)
|
|
|
529 {
|
|
|
530 cs_release_csp(i, TRUE);
|
|
|
531 goto add_err;
|
|
|
532 }
|
|
|
533
|
|
|
534 if (p_csverbose)
|
|
|
535 {
|
|
|
536 msg_clr_eos();
|
|
|
537 (void)smsg_attr(hl_attr(HLF_R),
|
|
|
538 (char_u *)_("Added cscope database %s"),
|
|
|
539 csinfo[i].fname);
|
|
|
540 }
|
|
|
541 }
|
|
|
542
|
|
|
543 vim_free(fname);
|
|
|
544 vim_free(fname2);
|
|
|
545 vim_free(ppath);
|
|
|
546 return CSCOPE_SUCCESS;
|
|
|
547
|
|
|
548 add_err:
|
|
|
549 vim_free(fname2);
|
|
|
550 vim_free(fname);
|
|
|
551 vim_free(ppath);
|
|
|
552 return CSCOPE_FAILURE;
|
|
|
553 } /* cs_add_common */
|
|
|
554
|
|
|
555
|
|
|
556 static int
|
|
|
557 cs_check_for_connections()
|
|
|
558 {
|
|
|
559 return (cs_cnt_connections() > 0);
|
|
|
560 } /* cs_check_for_connections */
|
|
|
561
|
|
|
562
|
|
|
563 static int
|
|
|
564 cs_check_for_tags()
|
|
|
565 {
|
|
301
|
566 return (p_tags[0] != NUL && curbuf->b_p_tags != NULL);
|
|
7
|
567 } /* cs_check_for_tags */
|
|
|
568
|
|
|
569
|
|
|
570 /*
|
|
|
571 * PRIVATE: cs_cnt_connections
|
|
|
572 *
|
|
|
573 * count the number of cscope connections
|
|
|
574 */
|
|
|
575 static int
|
|
|
576 cs_cnt_connections()
|
|
|
577 {
|
|
|
578 short i;
|
|
|
579 short cnt = 0;
|
|
|
580
|
|
|
581 for (i = 0; i < CSCOPE_MAX_CONNECTIONS; i++)
|
|
|
582 {
|
|
|
583 if (csinfo[i].fname != NULL)
|
|
|
584 cnt++;
|
|
|
585 }
|
|
|
586 return cnt;
|
|
|
587 } /* cs_cnt_connections */
|
|
|
588
|
|
|
589 static void
|
|
|
590 cs_reading_emsg(idx)
|
|
|
591 int idx; /* connection index */
|
|
|
592 {
|
|
|
593 EMSGN(_("E262: error reading cscope connection %ld"), idx);
|
|
|
594 }
|
|
|
595
|
|
|
596 #define CSREAD_BUFSIZE 2048
|
|
|
597 /*
|
|
|
598 * PRIVATE: cs_cnt_matches
|
|
|
599 *
|
|
|
600 * count the number of matches for a given cscope connection.
|
|
|
601 */
|
|
|
602 static int
|
|
|
603 cs_cnt_matches(idx)
|
|
|
604 int idx;
|
|
|
605 {
|
|
|
606 char *stok;
|
|
|
607 char *buf;
|
|
|
608 int nlines;
|
|
|
609
|
|
|
610 buf = (char *)alloc(CSREAD_BUFSIZE);
|
|
|
611 if (buf == NULL)
|
|
|
612 return 0;
|
|
|
613 for (;;)
|
|
|
614 {
|
|
|
615 if (!fgets(buf, CSREAD_BUFSIZE, csinfo[idx].fr_fp))
|
|
|
616 {
|
|
|
617 if (feof(csinfo[idx].fr_fp))
|
|
|
618 errno = EIO;
|
|
|
619
|
|
|
620 cs_reading_emsg(idx);
|
|
|
621
|
|
|
622 vim_free(buf);
|
|
|
623 return -1;
|
|
|
624 }
|
|
|
625
|
|
|
626 /*
|
|
|
627 * If the database is out of date, or there's some other problem,
|
|
|
628 * cscope will output error messages before the number-of-lines output.
|
|
|
629 * Display/discard any output that doesn't match what we want.
|
|
|
630 */
|
|
|
631 if ((stok = strtok(buf, (const char *)" ")) == NULL)
|
|
|
632 continue;
|
|
|
633 if (strcmp((const char *)stok, "cscope:"))
|
|
|
634 continue;
|
|
|
635
|
|
|
636 if ((stok = strtok(NULL, (const char *)" ")) == NULL)
|
|
|
637 continue;
|
|
|
638 nlines = atoi(stok);
|
|
|
639 if (nlines < 0)
|
|
|
640 {
|
|
|
641 nlines = 0;
|
|
|
642 break;
|
|
|
643 }
|
|
|
644
|
|
|
645 if ((stok = strtok(NULL, (const char *)" ")) == NULL)
|
|
|
646 continue;
|
|
|
647 if (strncmp((const char *)stok, "lines", 5))
|
|
|
648 continue;
|
|
|
649
|
|
|
650 break;
|
|
|
651 }
|
|
|
652
|
|
|
653 vim_free(buf);
|
|
|
654 return nlines;
|
|
|
655 } /* cs_cnt_matches */
|
|
|
656
|
|
|
657
|
|
|
658 /*
|
|
|
659 * PRIVATE: cs_create_cmd
|
|
|
660 *
|
|
|
661 * Creates the actual cscope command query from what the user entered.
|
|
|
662 */
|
|
|
663 static char *
|
|
|
664 cs_create_cmd(csoption, pattern)
|
|
|
665 char *csoption;
|
|
|
666 char *pattern;
|
|
|
667 {
|
|
|
668 char *cmd;
|
|
|
669 short search;
|
|
|
670
|
|
|
671 switch (csoption[0])
|
|
|
672 {
|
|
|
673 case '0' : case 's' :
|
|
|
674 search = 0;
|
|
|
675 break;
|
|
|
676 case '1' : case 'g' :
|
|
|
677 search = 1;
|
|
|
678 break;
|
|
|
679 case '2' : case 'd' :
|
|
|
680 search = 2;
|
|
|
681 break;
|
|
|
682 case '3' : case 'c' :
|
|
|
683 search = 3;
|
|
|
684 break;
|
|
|
685 case '4' : case 't' :
|
|
|
686 search = 4;
|
|
|
687 break;
|
|
|
688 case '6' : case 'e' :
|
|
|
689 search = 6;
|
|
|
690 break;
|
|
|
691 case '7' : case 'f' :
|
|
|
692 search = 7;
|
|
|
693 break;
|
|
|
694 case '8' : case 'i' :
|
|
|
695 search = 8;
|
|
|
696 break;
|
|
|
697 default :
|
|
|
698 (void)EMSG(_("E561: unknown cscope search type"));
|
|
|
699 cs_usage_msg(Find);
|
|
|
700 return NULL;
|
|
|
701 }
|
|
|
702
|
|
|
703 if ((cmd = (char *)alloc(strlen(pattern) + 2)) == NULL)
|
|
|
704 return NULL;
|
|
|
705
|
|
|
706 (void)sprintf(cmd, "%d%s", search, pattern);
|
|
|
707
|
|
|
708 return cmd;
|
|
|
709 } /* cs_create_cmd */
|
|
|
710
|
|
|
711
|
|
|
712 /*
|
|
|
713 * PRIVATE: cs_create_connection
|
|
|
714 *
|
|
|
715 * This piece of code was taken/adapted from nvi. do we need to add
|
|
|
716 * the BSD license notice?
|
|
|
717 */
|
|
|
718 static int
|
|
|
719 cs_create_connection(i)
|
|
|
720 int i;
|
|
|
721 {
|
|
|
722 int to_cs[2], from_cs[2], len;
|
|
|
723 char *prog, *cmd, *ppath = NULL;
|
|
|
724 #ifndef UNIX
|
|
|
725 int in_save, out_save, err_save;
|
|
|
726 int ph;
|
|
|
727 # ifdef FEAT_GUI
|
|
|
728 HWND activewnd = NULL;
|
|
|
729 HWND consolewnd = NULL;
|
|
|
730 # endif
|
|
|
731 #endif
|
|
|
732
|
|
|
733 /*
|
|
|
734 * Cscope reads from to_cs[0] and writes to from_cs[1]; vi reads from
|
|
|
735 * from_cs[0] and writes to to_cs[1].
|
|
|
736 */
|
|
|
737 to_cs[0] = to_cs[1] = from_cs[0] = from_cs[1] = -1;
|
|
|
738 if (pipe(to_cs) < 0 || pipe(from_cs) < 0)
|
|
|
739 {
|
|
|
740 (void)EMSG(_("E566: Could not create cscope pipes"));
|
|
|
741 err_closing:
|
|
|
742 if (to_cs[0] != -1)
|
|
|
743 (void)close(to_cs[0]);
|
|
|
744 if (to_cs[1] != -1)
|
|
|
745 (void)close(to_cs[1]);
|
|
|
746 if (from_cs[0] != -1)
|
|
|
747 (void)close(from_cs[0]);
|
|
|
748 if (from_cs[1] != -1)
|
|
|
749 (void)close(from_cs[1]);
|
|
|
750 return CSCOPE_FAILURE;
|
|
|
751 }
|
|
|
752
|
|
|
753 #if defined(UNIX)
|
|
|
754 switch (csinfo[i].pid = fork())
|
|
|
755 {
|
|
|
756 case -1:
|
|
|
757 (void)EMSG(_("E622: Could not fork for cscope"));
|
|
|
758 goto err_closing;
|
|
|
759 case 0: /* child: run cscope. */
|
|
|
760 #else
|
|
|
761 in_save = dup(STDIN_FILENO);
|
|
|
762 out_save = dup(STDOUT_FILENO);
|
|
|
763 err_save = dup(STDERR_FILENO);
|
|
|
764 #endif
|
|
|
765 if (dup2(to_cs[0], STDIN_FILENO) == -1)
|
|
|
766 PERROR("cs_create_connection 1");
|
|
|
767 if (dup2(from_cs[1], STDOUT_FILENO) == -1)
|
|
|
768 PERROR("cs_create_connection 2");
|
|
|
769 if (dup2(from_cs[1], STDERR_FILENO) == -1)
|
|
|
770 PERROR("cs_create_connection 3");
|
|
|
771
|
|
|
772 /* close unused */
|
|
|
773 #if defined(UNIX)
|
|
|
774 (void)close(to_cs[1]);
|
|
|
775 (void)close(from_cs[0]);
|
|
|
776 #else
|
|
|
777 /* On win32 we must close opposite ends because we are the parent */
|
|
|
778 (void)close(to_cs[0]);
|
|
|
779 to_cs[0] = -1;
|
|
|
780 (void)close(from_cs[1]);
|
|
|
781 from_cs[1] = -1;
|
|
|
782 #endif
|
|
|
783 /* expand the cscope exec for env var's */
|
|
|
784 if ((prog = (char *)alloc(MAXPATHL + 1)) == NULL)
|
|
|
785 {
|
|
|
786 #ifdef UNIX
|
|
|
787 return CSCOPE_FAILURE;
|
|
|
788 #else
|
|
|
789 goto err_closing;
|
|
|
790 #endif
|
|
|
791 }
|
|
|
792 expand_env((char_u *)p_csprg, (char_u *)prog, MAXPATHL);
|
|
|
793
|
|
|
794 /* alloc space to hold the cscope command */
|
|
|
795 len = strlen(prog) + strlen(csinfo[i].fname) + 32;
|
|
|
796 if (csinfo[i].ppath)
|
|
|
797 {
|
|
|
798 /* expand the prepend path for env var's */
|
|
|
799 if ((ppath = (char *)alloc(MAXPATHL + 1)) == NULL)
|
|
|
800 {
|
|
|
801 vim_free(prog);
|
|
|
802 #ifdef UNIX
|
|
|
803 return CSCOPE_FAILURE;
|
|
|
804 #else
|
|
|
805 goto err_closing;
|
|
|
806 #endif
|
|
|
807 }
|
|
|
808 expand_env((char_u *)csinfo[i].ppath, (char_u *)ppath, MAXPATHL);
|
|
|
809
|
|
|
810 len += strlen(ppath);
|
|
|
811 }
|
|
|
812
|
|
|
813 if (csinfo[i].flags)
|
|
|
814 len += strlen(csinfo[i].flags);
|
|
|
815
|
|
|
816 if ((cmd = (char *)alloc(len)) == NULL)
|
|
|
817 {
|
|
|
818 vim_free(prog);
|
|
|
819 vim_free(ppath);
|
|
|
820 #ifdef UNIX
|
|
|
821 return CSCOPE_FAILURE;
|
|
|
822 #else
|
|
|
823 goto err_closing;
|
|
|
824 #endif
|
|
|
825 }
|
|
|
826
|
|
|
827 /* run the cscope command; is there execl for non-unix systems? */
|
|
|
828 #if defined(UNIX)
|
|
|
829 (void)sprintf(cmd, "exec %s -dl -f %s", prog, csinfo[i].fname);
|
|
|
830 #else
|
|
|
831 (void)sprintf(cmd, "%s -dl -f %s", prog, csinfo[i].fname);
|
|
|
832 #endif
|
|
|
833 if (csinfo[i].ppath != NULL)
|
|
|
834 {
|
|
|
835 (void)strcat(cmd, " -P");
|
|
|
836 (void)strcat(cmd, csinfo[i].ppath);
|
|
|
837 }
|
|
|
838 if (csinfo[i].flags != NULL)
|
|
|
839 {
|
|
|
840 (void)strcat(cmd, " ");
|
|
|
841 (void)strcat(cmd, csinfo[i].flags);
|
|
|
842 }
|
|
|
843 # ifdef UNIX
|
|
|
844 /* on Win32 we still need prog */
|
|
|
845 vim_free(prog);
|
|
|
846 # endif
|
|
|
847 vim_free(ppath);
|
|
|
848
|
|
|
849 #if defined(UNIX)
|
|
|
850 if (execl("/bin/sh", "sh", "-c", cmd, NULL) == -1)
|
|
|
851 PERROR(_("cs_create_connection exec failed"));
|
|
|
852
|
|
|
853 exit(127);
|
|
|
854 /* NOTREACHED */
|
|
|
855 default: /* parent. */
|
|
|
856 #else
|
|
|
857 # ifdef FEAT_GUI
|
|
|
858 activewnd = GetForegroundWindow(); /* on win9x cscope steals focus */
|
|
|
859 /* Dirty hack to hide annoying console window */
|
|
|
860 if (AllocConsole())
|
|
|
861 {
|
|
|
862 char *title;
|
|
|
863 title = (char *)alloc(1024);
|
|
|
864 if (title == NULL)
|
|
|
865 FreeConsole();
|
|
|
866 else
|
|
|
867 {
|
|
|
868 GetConsoleTitle(title, 1024); /* save for future restore */
|
|
|
869 SetConsoleTitle(
|
|
|
870 "GVIMCS{5499421B-CBEF-45b0-85EF-38167FDEA5C5}GVIMCS");
|
|
|
871 Sleep(40); /* as stated in MS KB we must wait 40 ms */
|
|
|
872 consolewnd = FindWindow(NULL,
|
|
|
873 "GVIMCS{5499421B-CBEF-45b0-85EF-38167FDEA5C5}GVIMCS");
|
|
|
874 if (consolewnd != NULL)
|
|
|
875 ShowWindow(consolewnd, SW_HIDE);
|
|
|
876 SetConsoleTitle(title);
|
|
|
877 vim_free(title);
|
|
|
878 }
|
|
|
879 }
|
|
|
880 # endif
|
|
|
881 /* May be use &shell, &shellquote etc */
|
|
|
882 # ifdef __BORLANDC__
|
|
|
883 /* BCC 5.5 uses a different function name for spawnlp */
|
|
|
884 ph = spawnlp(P_NOWAIT, prog, cmd, NULL);
|
|
|
885 # else
|
|
|
886 ph = _spawnlp(_P_NOWAIT, prog, cmd, NULL);
|
|
|
887 # endif
|
|
|
888 vim_free(prog);
|
|
|
889 vim_free(cmd);
|
|
|
890 # ifdef FEAT_GUI
|
|
|
891 /* Dirty hack part two */
|
|
|
892 if (activewnd != NULL)
|
|
|
893 /* restoring focus */
|
|
|
894 SetForegroundWindow(activewnd);
|
|
|
895 if (consolewnd != NULL)
|
|
|
896 FreeConsole();
|
|
|
897
|
|
|
898 # endif
|
|
|
899 if (ph == -1)
|
|
|
900 {
|
|
|
901 PERROR(_("cs_create_connection exec failed"));
|
|
|
902 (void)EMSG(_("E623: Could not spawn cscope process"));
|
|
|
903 goto err_closing;
|
|
|
904 }
|
|
|
905 /* else */
|
|
|
906 csinfo[i].pid = 0;
|
|
|
907 csinfo[i].hProc = (HANDLE)ph;
|
|
|
908
|
|
|
909 #endif /* !UNIX */
|
|
|
910 /*
|
|
|
911 * Save the file descriptors for later duplication, and
|
|
|
912 * reopen as streams.
|
|
|
913 */
|
|
|
914 if ((csinfo[i].to_fp = fdopen(to_cs[1], "w")) == NULL)
|
|
|
915 PERROR(_("cs_create_connection: fdopen for to_fp failed"));
|
|
|
916 if ((csinfo[i].fr_fp = fdopen(from_cs[0], "r")) == NULL)
|
|
|
917 PERROR(_("cs_create_connection: fdopen for fr_fp failed"));
|
|
|
918
|
|
|
919 #if defined(UNIX)
|
|
|
920 /* close unused */
|
|
|
921 (void)close(to_cs[0]);
|
|
|
922 (void)close(from_cs[1]);
|
|
|
923
|
|
|
924 break;
|
|
|
925 }
|
|
|
926 #else
|
|
|
927 /* restore stdhandles */
|
|
|
928 dup2(in_save, STDIN_FILENO);
|
|
|
929 dup2(out_save, STDOUT_FILENO);
|
|
|
930 dup2(err_save, STDERR_FILENO);
|
|
|
931 close(in_save);
|
|
|
932 close(out_save);
|
|
|
933 close(err_save);
|
|
|
934 #endif
|
|
|
935 return CSCOPE_SUCCESS;
|
|
|
936 } /* cs_create_connection */
|
|
|
937
|
|
|
938
|
|
|
939 /*
|
|
|
940 * PRIVATE: cs_find
|
|
|
941 *
|
|
|
942 * query cscope using command line interface. parse the output and use tselect
|
|
|
943 * to allow choices. like Nvi, creates a pipe to send to/from query/cscope.
|
|
|
944 *
|
|
|
945 * returns TRUE if we jump to a tag or abort, FALSE if not.
|
|
|
946 */
|
|
|
947 static int
|
|
|
948 cs_find(eap)
|
|
|
949 exarg_T *eap;
|
|
|
950 {
|
|
|
951 char *opt, *pat;
|
|
|
952
|
|
|
953 if (cs_check_for_connections() == FALSE)
|
|
|
954 {
|
|
|
955 (void)EMSG(_("E567: no cscope connections"));
|
|
|
956 return FALSE;
|
|
|
957 }
|
|
|
958
|
|
|
959 if ((opt = strtok((char *)NULL, (const char *)" ")) == NULL)
|
|
|
960 {
|
|
|
961 cs_usage_msg(Find);
|
|
|
962 return FALSE;
|
|
|
963 }
|
|
|
964
|
|
|
965 pat = opt + strlen(opt) + 1;
|
|
|
966 if (pat == NULL || (pat != NULL && pat[0] == '\0'))
|
|
|
967 {
|
|
|
968 cs_usage_msg(Find);
|
|
|
969 return FALSE;
|
|
|
970 }
|
|
|
971
|
|
665
|
972 return cs_find_common(opt, pat, eap->forceit, TRUE,
|
|
|
973 eap->cmdidx == CMD_lcscope);
|
|
7
|
974 } /* cs_find */
|
|
|
975
|
|
|
976
|
|
|
977 /*
|
|
|
978 * PRIVATE: cs_find_common
|
|
|
979 *
|
|
|
980 * common code for cscope find, shared by cs_find() and do_cstag()
|
|
|
981 */
|
|
|
982 static int
|
|
665
|
983 cs_find_common(opt, pat, forceit, verbose, use_ll)
|
|
7
|
984 char *opt;
|
|
|
985 char *pat;
|
|
|
986 int forceit;
|
|
|
987 int verbose;
|
|
665
|
988 int use_ll;
|
|
7
|
989 {
|
|
|
990 int i;
|
|
|
991 char *cmd;
|
|
|
992 char **matches, **contexts;
|
|
|
993 int nummatches[CSCOPE_MAX_CONNECTIONS], totmatches, matched;
|
|
|
994 #ifdef FEAT_QUICKFIX
|
|
|
995 char cmdletter;
|
|
|
996 char *qfpos;
|
|
|
997 #endif
|
|
|
998
|
|
|
999 /* create the actual command to send to cscope */
|
|
|
1000 cmd = cs_create_cmd(opt, pat);
|
|
|
1001 if (cmd == NULL)
|
|
|
1002 return FALSE;
|
|
|
1003
|
|
|
1004 /* send query to all open connections, then count the total number
|
|
|
1005 * of matches so we can alloc matchesp all in one swell foop
|
|
|
1006 */
|
|
|
1007 for (i = 0; i < CSCOPE_MAX_CONNECTIONS; i++)
|
|
|
1008 nummatches[i] = 0;
|
|
|
1009 totmatches = 0;
|
|
|
1010 for (i = 0; i < CSCOPE_MAX_CONNECTIONS; i++)
|
|
|
1011 {
|
|
|
1012 if (csinfo[i].fname == NULL)
|
|
|
1013 continue;
|
|
|
1014
|
|
|
1015 /* send cmd to cscope */
|
|
|
1016 (void)fprintf(csinfo[i].to_fp, "%s\n", cmd);
|
|
|
1017 (void)fflush(csinfo[i].to_fp);
|
|
|
1018
|
|
|
1019 nummatches[i] = cs_cnt_matches(i);
|
|
|
1020
|
|
|
1021 if (nummatches[i] > -1)
|
|
|
1022 totmatches += nummatches[i];
|
|
|
1023
|
|
|
1024 if (nummatches[i] == 0)
|
|
|
1025 (void)cs_read_prompt(i);
|
|
|
1026 }
|
|
|
1027 vim_free(cmd);
|
|
|
1028
|
|
|
1029 if (totmatches == 0)
|
|
|
1030 {
|
|
|
1031 char *nf = _("E259: no matches found for cscope query %s of %s");
|
|
|
1032 char *buf;
|
|
|
1033
|
|
|
1034 if (!verbose)
|
|
|
1035 return FALSE;
|
|
|
1036
|
|
|
1037 buf = (char *)alloc(strlen(opt) + strlen(pat) + strlen(nf));
|
|
|
1038 if (buf == NULL)
|
|
|
1039 (void)EMSG(nf);
|
|
|
1040 else
|
|
|
1041 {
|
|
|
1042 sprintf(buf, nf, opt, pat);
|
|
|
1043 (void)EMSG(buf);
|
|
|
1044 vim_free(buf);
|
|
|
1045 }
|
|
|
1046 return FALSE;
|
|
|
1047 }
|
|
|
1048
|
|
|
1049 #ifdef FEAT_QUICKFIX
|
|
|
1050 /* get cmd letter */
|
|
|
1051 switch (opt[0])
|
|
|
1052 {
|
|
|
1053 case '0' :
|
|
|
1054 cmdletter = 's';
|
|
|
1055 break;
|
|
|
1056 case '1' :
|
|
|
1057 cmdletter = 'g';
|
|
|
1058 break;
|
|
|
1059 case '2' :
|
|
|
1060 cmdletter = 'd';
|
|
|
1061 break;
|
|
|
1062 case '3' :
|
|
|
1063 cmdletter = 'c';
|
|
|
1064 break;
|
|
|
1065 case '4' :
|
|
|
1066 cmdletter = 't';
|
|
|
1067 break;
|
|
|
1068 case '6' :
|
|
|
1069 cmdletter = 'e';
|
|
|
1070 break;
|
|
|
1071 case '7' :
|
|
|
1072 cmdletter = 'f';
|
|
|
1073 break;
|
|
|
1074 case '8' :
|
|
|
1075 cmdletter = 'i';
|
|
|
1076 break;
|
|
|
1077 default :
|
|
|
1078 cmdletter = opt[0];
|
|
|
1079 }
|
|
|
1080
|
|
|
1081 qfpos = (char *)vim_strchr(p_csqf, cmdletter);
|
|
|
1082 if (qfpos != NULL)
|
|
|
1083 {
|
|
|
1084 qfpos++;
|
|
|
1085 /* next symbol must be + or - */
|
|
|
1086 if (strchr(CSQF_FLAGS, *qfpos) == NULL)
|
|
|
1087 {
|
|
|
1088 char *nf = _("E469: invalid cscopequickfix flag %c for %c");
|
|
|
1089 char *buf = (char *)alloc(strlen(nf));
|
|
|
1090
|
|
|
1091 /* strlen will be enough because we use chars */
|
|
|
1092 if (buf != NULL)
|
|
|
1093 {
|
|
|
1094 sprintf(buf, nf, *qfpos, *(qfpos-1));
|
|
|
1095 (void)EMSG(buf);
|
|
|
1096 vim_free(buf);
|
|
|
1097 }
|
|
|
1098 return FALSE;
|
|
|
1099 }
|
|
|
1100 }
|
|
36
|
1101 if (qfpos != NULL && *qfpos != '0' && totmatches > 0)
|
|
7
|
1102 {
|
|
|
1103 /* fill error list */
|
|
|
1104 FILE *f;
|
|
|
1105 char_u *tmp = vim_tempname('c');
|
|
665
|
1106 qf_info_T *qi = NULL;
|
|
|
1107 win_T *wp = NULL;
|
|
7
|
1108
|
|
531
|
1109 f = mch_fopen((char *)tmp, "w");
|
|
7
|
1110 cs_file_results(f, nummatches);
|
|
|
1111 fclose(f);
|
|
665
|
1112 if (use_ll) /* Use location list */
|
|
|
1113 wp = curwin;
|
|
7
|
1114 /* '-' starts a new error list */
|
|
665
|
1115 if (qf_init(wp, tmp, (char_u *)"%f%*\\t%l%*\\t%m", *qfpos == '-') > 0)
|
|
7
|
1116 {
|
|
|
1117 # ifdef FEAT_WINDOWS
|
|
|
1118 if (postponed_split != 0)
|
|
|
1119 {
|
|
|
1120 win_split(postponed_split > 0 ? postponed_split : 0,
|
|
|
1121 postponed_split_flags);
|
|
|
1122 # ifdef FEAT_SCROLLBIND
|
|
|
1123 curwin->w_p_scb = FALSE;
|
|
|
1124 # endif
|
|
|
1125 postponed_split = 0;
|
|
|
1126 }
|
|
|
1127 # endif
|
|
665
|
1128 if (use_ll)
|
|
|
1129 /*
|
|
|
1130 * In the location list window, use the displayed location
|
|
|
1131 * list. Otherwise, use the location list for the window.
|
|
|
1132 */
|
|
|
1133 qi = (bt_quickfix(wp->w_buffer) && wp->w_llist_ref != NULL) ?
|
|
|
1134 wp->w_llist_ref : wp->w_llist;
|
|
|
1135 qf_jump(qi, 0, 0, forceit);
|
|
7
|
1136 }
|
|
|
1137 mch_remove(tmp);
|
|
|
1138 vim_free(tmp);
|
|
|
1139 return TRUE;
|
|
|
1140 }
|
|
|
1141 else
|
|
|
1142 #endif /* FEAT_QUICKFIX */
|
|
|
1143 {
|
|
|
1144 /* read output */
|
|
|
1145 cs_fill_results((char *)pat, totmatches, nummatches, &matches,
|
|
|
1146 &contexts, &matched);
|
|
|
1147 if (matches == NULL)
|
|
|
1148 return FALSE;
|
|
|
1149
|
|
293
|
1150 (void)cs_manage_matches(matches, contexts, matched, Store);
|
|
7
|
1151
|
|
|
1152 return do_tag((char_u *)pat, DT_CSCOPE, 0, forceit, verbose);
|
|
|
1153 }
|
|
|
1154
|
|
|
1155 } /* cs_find_common */
|
|
|
1156
|
|
|
1157 /*
|
|
|
1158 * PRIVATE: cs_help
|
|
|
1159 *
|
|
|
1160 * print help
|
|
|
1161 */
|
|
|
1162 /* ARGSUSED */
|
|
|
1163 static int
|
|
|
1164 cs_help(eap)
|
|
|
1165 exarg_T *eap;
|
|
|
1166 {
|
|
|
1167 cscmd_T *cmdp = cs_cmds;
|
|
|
1168
|
|
|
1169 (void)MSG_PUTS(_("cscope commands:\n"));
|
|
|
1170 while (cmdp->name != NULL)
|
|
|
1171 {
|
|
|
1172 (void)smsg((char_u *)_("%-5s: %-30s (Usage: %s)"),
|
|
|
1173 cmdp->name, _(cmdp->help), cmdp->usage);
|
|
|
1174 if (strcmp(cmdp->name, "find") == 0)
|
|
|
1175 MSG_PUTS(FIND_HELP);
|
|
|
1176 cmdp++;
|
|
|
1177 }
|
|
|
1178
|
|
|
1179 wait_return(TRUE);
|
|
|
1180 return 0;
|
|
|
1181 } /* cs_help */
|
|
|
1182
|
|
|
1183
|
|
|
1184 /*
|
|
|
1185 * PRIVATE: cs_init
|
|
|
1186 *
|
|
|
1187 * initialize cscope structure if not already
|
|
|
1188 */
|
|
|
1189 static void
|
|
|
1190 cs_init()
|
|
|
1191 {
|
|
|
1192 short i;
|
|
|
1193 static int init_already = FALSE;
|
|
|
1194
|
|
|
1195 if (init_already)
|
|
|
1196 return;
|
|
|
1197
|
|
|
1198 for (i = 0; i < CSCOPE_MAX_CONNECTIONS; i++)
|
|
|
1199 clear_csinfo(i);
|
|
|
1200
|
|
|
1201 init_already = TRUE;
|
|
|
1202 } /* cs_init */
|
|
|
1203
|
|
|
1204 static void
|
|
|
1205 clear_csinfo(i)
|
|
|
1206 int i;
|
|
|
1207 {
|
|
|
1208 csinfo[i].fname = NULL;
|
|
|
1209 csinfo[i].ppath = NULL;
|
|
|
1210 csinfo[i].flags = NULL;
|
|
|
1211 #if defined(UNIX)
|
|
|
1212 csinfo[i].st_dev = (dev_t)0;
|
|
|
1213 csinfo[i].st_ino = (ino_t)0;
|
|
|
1214 #else
|
|
|
1215 csinfo[i].nVolume = 0;
|
|
|
1216 csinfo[i].nIndexHigh = 0;
|
|
|
1217 csinfo[i].nIndexLow = 0;
|
|
|
1218 #endif
|
|
|
1219 csinfo[i].pid = -1;
|
|
|
1220 csinfo[i].fr_fp = NULL;
|
|
|
1221 csinfo[i].to_fp = NULL;
|
|
301
|
1222 #if defined(WIN32)
|
|
|
1223 csinfo[i].hProc = NULL;
|
|
|
1224 #endif
|
|
7
|
1225 }
|
|
|
1226
|
|
|
1227 #ifndef UNIX
|
|
|
1228 static char *GetWin32Error __ARGS((void));
|
|
|
1229
|
|
|
1230 static char *
|
|
|
1231 GetWin32Error()
|
|
|
1232 {
|
|
|
1233 char *msg = NULL;
|
|
|
1234 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
|
|
|
1235 NULL, GetLastError(), 0, (LPSTR)&msg, 0, NULL);
|
|
|
1236 if (msg != NULL)
|
|
|
1237 {
|
|
|
1238 /* remove trailing \r\n */
|
|
|
1239 char *pcrlf = strstr(msg, "\r\n");
|
|
|
1240 if (pcrlf != NULL)
|
|
|
1241 *pcrlf = '\0';
|
|
|
1242 }
|
|
|
1243 return msg;
|
|
|
1244 }
|
|
|
1245 #endif
|
|
323
|
1246
|
|
7
|
1247 /*
|
|
|
1248 * PRIVATE: cs_insert_filelist
|
|
|
1249 *
|
|
|
1250 * insert a new cscope database filename into the filelist
|
|
|
1251 */
|
|
323
|
1252 /*ARGSUSED*/
|
|
7
|
1253 static int
|
|
|
1254 cs_insert_filelist(fname, ppath, flags, sb)
|
|
|
1255 char *fname;
|
|
|
1256 char *ppath;
|
|
|
1257 char *flags;
|
|
|
1258 struct stat *sb;
|
|
|
1259 {
|
|
|
1260 short i, j;
|
|
|
1261 #ifndef UNIX
|
|
|
1262 HANDLE hFile;
|
|
|
1263 BY_HANDLE_FILE_INFORMATION bhfi;
|
|
|
1264
|
|
|
1265 vim_memset(&bhfi, 0, sizeof(bhfi));
|
|
|
1266 /* On windows 9x GetFileInformationByHandle doesn't work, so skip it */
|
|
|
1267 if (!mch_windows95())
|
|
|
1268 {
|
|
|
1269 hFile = CreateFile(fname, FILE_READ_ATTRIBUTES, 0, NULL, OPEN_EXISTING,
|
|
|
1270 FILE_ATTRIBUTE_NORMAL, NULL);
|
|
|
1271 if (hFile == INVALID_HANDLE_VALUE)
|
|
|
1272 {
|
|
|
1273 if (p_csverbose)
|
|
|
1274 {
|
|
|
1275 char *cant_msg = _("E625: cannot open cscope database: %s");
|
|
|
1276 char *winmsg = GetWin32Error();
|
|
|
1277
|
|
|
1278 if (winmsg != NULL)
|
|
|
1279 {
|
|
|
1280 (void)EMSG2(cant_msg, winmsg);
|
|
|
1281 LocalFree(winmsg);
|
|
|
1282 }
|
|
|
1283 else
|
|
|
1284 /* subst filename if can't get error text */
|
|
|
1285 (void)EMSG2(cant_msg, fname);
|
|
|
1286 }
|
|
|
1287 return -1;
|
|
|
1288 }
|
|
|
1289 if (!GetFileInformationByHandle(hFile, &bhfi))
|
|
|
1290 {
|
|
|
1291 CloseHandle(hFile);
|
|
|
1292 if (p_csverbose)
|
|
|
1293 (void)EMSG(_("E626: cannot get cscope database information"));
|
|
|
1294 return -1;
|
|
|
1295 }
|
|
|
1296 CloseHandle(hFile);
|
|
|
1297 }
|
|
|
1298 #endif
|
|
|
1299
|
|
|
1300 i = -1; /* can be set to the index of an empty item in csinfo */
|
|
|
1301 for (j = 0; j < CSCOPE_MAX_CONNECTIONS; j++)
|
|
|
1302 {
|
|
|
1303 if (csinfo[j].fname != NULL
|
|
|
1304 #if defined(UNIX)
|
|
|
1305 && csinfo[j].st_dev == sb->st_dev && csinfo[j].st_ino == sb->st_ino
|
|
|
1306 #else
|
|
|
1307 /* compare pathnames first */
|
|
|
1308 && ((fullpathcmp(csinfo[j].fname, fname, FALSE) & FPC_SAME)
|
|
|
1309 /* if not Windows 9x, test index file atributes too */
|
|
|
1310 || (!mch_windows95()
|
|
|
1311 && csinfo[j].nVolume == bhfi.dwVolumeSerialNumber
|
|
|
1312 && csinfo[j].nIndexHigh == bhfi.nFileIndexHigh
|
|
|
1313 && csinfo[j].nIndexLow == bhfi.nFileIndexLow))
|
|
|
1314 #endif
|
|
|
1315 )
|
|
|
1316 {
|
|
|
1317 if (p_csverbose)
|
|
|
1318 (void)EMSG(_("E568: duplicate cscope database not added"));
|
|
|
1319 return -1;
|
|
|
1320 }
|
|
|
1321
|
|
|
1322 if (csinfo[j].fname == NULL && i == -1)
|
|
|
1323 i = j; /* remember first empty entry */
|
|
|
1324 }
|
|
|
1325
|
|
|
1326 if (i == -1)
|
|
|
1327 {
|
|
|
1328 if (p_csverbose)
|
|
|
1329 (void)EMSG(_("E569: maximum number of cscope connections reached"));
|
|
|
1330 return -1;
|
|
|
1331 }
|
|
|
1332
|
|
|
1333 if ((csinfo[i].fname = (char *)alloc(strlen(fname)+1)) == NULL)
|
|
|
1334 return -1;
|
|
|
1335
|
|
|
1336 (void)strcpy(csinfo[i].fname, (const char *)fname);
|
|
|
1337
|
|
|
1338 if (ppath != NULL)
|
|
|
1339 {
|
|
|
1340 if ((csinfo[i].ppath = (char *)alloc(strlen(ppath) + 1)) == NULL)
|
|
|
1341 {
|
|
|
1342 vim_free(csinfo[i].fname);
|
|
|
1343 csinfo[i].fname = NULL;
|
|
|
1344 return -1;
|
|
|
1345 }
|
|
|
1346 (void)strcpy(csinfo[i].ppath, (const char *)ppath);
|
|
|
1347 } else
|
|
|
1348 csinfo[i].ppath = NULL;
|
|
|
1349
|
|
|
1350 if (flags != NULL)
|
|
|
1351 {
|
|
|
1352 if ((csinfo[i].flags = (char *)alloc(strlen(flags) + 1)) == NULL)
|
|
|
1353 {
|
|
|
1354 vim_free(csinfo[i].fname);
|
|
|
1355 vim_free(csinfo[i].ppath);
|
|
|
1356 csinfo[i].fname = NULL;
|
|
|
1357 csinfo[i].ppath = NULL;
|
|
|
1358 return -1;
|
|
|
1359 }
|
|
|
1360 (void)strcpy(csinfo[i].flags, (const char *)flags);
|
|
|
1361 } else
|
|
|
1362 csinfo[i].flags = NULL;
|
|
|
1363
|
|
|
1364 #if defined(UNIX)
|
|
|
1365 csinfo[i].st_dev = sb->st_dev;
|
|
|
1366 csinfo[i].st_ino = sb->st_ino;
|
|
|
1367
|
|
|
1368 #else
|
|
|
1369 csinfo[i].nVolume = bhfi.dwVolumeSerialNumber;
|
|
|
1370 csinfo[i].nIndexLow = bhfi.nFileIndexLow;
|
|
|
1371 csinfo[i].nIndexHigh = bhfi.nFileIndexHigh;
|
|
|
1372 #endif
|
|
|
1373 return i;
|
|
|
1374 } /* cs_insert_filelist */
|
|
|
1375
|
|
|
1376
|
|
|
1377 /*
|
|
|
1378 * PRIVATE: cs_lookup_cmd
|
|
|
1379 *
|
|
|
1380 * find cscope command in command table
|
|
|
1381 */
|
|
|
1382 static cscmd_T *
|
|
|
1383 cs_lookup_cmd(eap)
|
|
|
1384 exarg_T *eap;
|
|
|
1385 {
|
|
|
1386 cscmd_T *cmdp;
|
|
|
1387 char *stok;
|
|
|
1388 size_t len;
|
|
|
1389
|
|
|
1390 if (eap->arg == NULL)
|
|
|
1391 return NULL;
|
|
|
1392
|
|
|
1393 if ((stok = strtok((char *)(eap->arg), (const char *)" ")) == NULL)
|
|
|
1394 return NULL;
|
|
|
1395
|
|
|
1396 len = strlen(stok);
|
|
|
1397 for (cmdp = cs_cmds; cmdp->name != NULL; ++cmdp)
|
|
|
1398 {
|
|
|
1399 if (strncmp((const char *)(stok), cmdp->name, len) == 0)
|
|
|
1400 return (cmdp);
|
|
|
1401 }
|
|
|
1402 return NULL;
|
|
|
1403 } /* cs_lookup_cmd */
|
|
|
1404
|
|
|
1405
|
|
|
1406 /*
|
|
|
1407 * PRIVATE: cs_kill
|
|
|
1408 *
|
|
|
1409 * nuke em
|
|
|
1410 */
|
|
|
1411 /* ARGSUSED */
|
|
|
1412 static int
|
|
|
1413 cs_kill(eap)
|
|
|
1414 exarg_T *eap;
|
|
|
1415 {
|
|
|
1416 char *stok;
|
|
|
1417 short i;
|
|
|
1418
|
|
|
1419 if ((stok = strtok((char *)NULL, (const char *)" ")) == NULL)
|
|
|
1420 {
|
|
|
1421 cs_usage_msg(Kill);
|
|
|
1422 return CSCOPE_FAILURE;
|
|
|
1423 }
|
|
|
1424
|
|
|
1425 /* only single digit positive and negative integers are allowed */
|
|
|
1426 if ((strlen(stok) < 2 && VIM_ISDIGIT((int)(stok[0])))
|
|
|
1427 || (strlen(stok) < 3 && stok[0] == '-'
|
|
|
1428 && VIM_ISDIGIT((int)(stok[1]))))
|
|
|
1429 i = atoi(stok);
|
|
|
1430 else
|
|
|
1431 {
|
|
|
1432 /* It must be part of a name. We will try to find a match
|
|
|
1433 * within all the names in the csinfo data structure
|
|
|
1434 */
|
|
|
1435 for (i = 0; i < CSCOPE_MAX_CONNECTIONS; i++)
|
|
|
1436 {
|
|
|
1437 if (csinfo[i].fname != NULL && strstr(csinfo[i].fname, stok))
|
|
|
1438 break;
|
|
|
1439 }
|
|
|
1440 }
|
|
|
1441
|
|
|
1442 if ((i >= CSCOPE_MAX_CONNECTIONS || i < -1 || csinfo[i].fname == NULL)
|
|
|
1443 && i != -1)
|
|
|
1444 {
|
|
|
1445 if (p_csverbose)
|
|
|
1446 (void)EMSG2(_("E261: cscope connection %s not found"), stok);
|
|
|
1447 }
|
|
|
1448 else
|
|
|
1449 {
|
|
|
1450 if (i == -1)
|
|
|
1451 {
|
|
|
1452 for (i = 0; i < CSCOPE_MAX_CONNECTIONS; i++)
|
|
|
1453 {
|
|
|
1454 if (csinfo[i].fname)
|
|
|
1455 cs_kill_execute(i, csinfo[i].fname);
|
|
|
1456 }
|
|
|
1457 }
|
|
|
1458 else
|
|
|
1459 cs_kill_execute(i, stok);
|
|
|
1460 }
|
|
|
1461
|
|
|
1462 return 0;
|
|
|
1463 } /* cs_kill */
|
|
|
1464
|
|
|
1465
|
|
|
1466 /*
|
|
|
1467 * PRIVATE: cs_kill_execute
|
|
|
1468 *
|
|
|
1469 * Actually kills a specific cscope connection.
|
|
|
1470 */
|
|
|
1471 static void
|
|
|
1472 cs_kill_execute(i, cname)
|
|
|
1473 int i; /* cscope table index */
|
|
|
1474 char *cname; /* cscope database name */
|
|
|
1475 {
|
|
|
1476 if (p_csverbose)
|
|
|
1477 {
|
|
|
1478 msg_clr_eos();
|
|
|
1479 (void)smsg_attr(hl_attr(HLF_R) | MSG_HIST,
|
|
|
1480 (char_u *)_("cscope connection %s closed"), cname);
|
|
|
1481 }
|
|
|
1482 cs_release_csp(i, TRUE);
|
|
|
1483 }
|
|
|
1484
|
|
|
1485
|
|
|
1486 /*
|
|
|
1487 * PRIVATE: cs_make_vim_style_matches
|
|
|
1488 *
|
|
|
1489 * convert the cscope output into into a ctags style entry (as might be found
|
|
|
1490 * in a ctags tags file). there's one catch though: cscope doesn't tell you
|
|
|
1491 * the type of the tag you are looking for. for example, in Darren Hiebert's
|
|
|
1492 * ctags (the one that comes with vim), #define's use a line number to find the
|
|
|
1493 * tag in a file while function definitions use a regexp search pattern.
|
|
|
1494 *
|
|
|
1495 * i'm going to always use the line number because cscope does something
|
|
|
1496 * quirky (and probably other things i don't know about):
|
|
|
1497 *
|
|
|
1498 * if you have "# define" in your source file, which is
|
|
|
1499 * perfectly legal, cscope thinks you have "#define". this
|
|
|
1500 * will result in a failed regexp search. :(
|
|
|
1501 *
|
|
|
1502 * besides, even if this particular case didn't happen, the search pattern
|
|
|
1503 * would still have to be modified to escape all the special regular expression
|
|
|
1504 * characters to comply with ctags formatting.
|
|
|
1505 */
|
|
|
1506 static char *
|
|
|
1507 cs_make_vim_style_matches(fname, slno, search, tagstr)
|
|
|
1508 char *fname;
|
|
|
1509 char *slno;
|
|
|
1510 char *search;
|
|
|
1511 char *tagstr;
|
|
|
1512 {
|
|
|
1513 /* vim style is ctags:
|
|
|
1514 *
|
|
|
1515 * <tagstr>\t<filename>\t<linenum_or_search>"\t<extra>
|
|
|
1516 *
|
|
|
1517 * but as mentioned above, we'll always use the line number and
|
|
|
1518 * put the search pattern (if one exists) as "extra"
|
|
|
1519 *
|
|
|
1520 * buf is used as part of vim's method of handling tags, and
|
|
|
1521 * (i think) vim frees it when you pop your tags and get replaced
|
|
|
1522 * by new ones on the tag stack.
|
|
|
1523 */
|
|
|
1524 char *buf;
|
|
|
1525 int amt;
|
|
|
1526
|
|
|
1527 if (search != NULL)
|
|
|
1528 {
|
|
|
1529 amt = strlen(fname) + strlen(slno) + strlen(tagstr) + strlen(search)+6;
|
|
|
1530 if ((buf = (char *)alloc(amt)) == NULL)
|
|
|
1531 return NULL;
|
|
|
1532
|
|
|
1533 (void)sprintf(buf, "%s\t%s\t%s;\"\t%s", tagstr, fname, slno, search);
|
|
|
1534 }
|
|
|
1535 else
|
|
|
1536 {
|
|
|
1537 amt = strlen(fname) + strlen(slno) + strlen(tagstr) + 5;
|
|
|
1538 if ((buf = (char *)alloc(amt)) == NULL)
|
|
|
1539 return NULL;
|
|
|
1540
|
|
|
1541 (void)sprintf(buf, "%s\t%s\t%s;\"", tagstr, fname, slno);
|
|
|
1542 }
|
|
|
1543
|
|
|
1544 return buf;
|
|
|
1545 } /* cs_make_vim_style_matches */
|
|
|
1546
|
|
|
1547
|
|
|
1548 /*
|
|
|
1549 * PRIVATE: cs_manage_matches
|
|
|
1550 *
|
|
|
1551 * this is kind of hokey, but i don't see an easy way round this..
|
|
|
1552 *
|
|
|
1553 * Store: keep a ptr to the (malloc'd) memory of matches originally
|
|
|
1554 * generated from cs_find(). the matches are originally lines directly
|
|
|
1555 * from cscope output, but transformed to look like something out of a
|
|
|
1556 * ctags. see cs_make_vim_style_matches for more details.
|
|
|
1557 *
|
|
|
1558 * Get: used only from cs_fgets(), this simulates a vim_fgets() to return
|
|
|
1559 * the next line from the cscope output. it basically keeps track of which
|
|
|
1560 * lines have been "used" and returns the next one.
|
|
|
1561 *
|
|
|
1562 * Free: frees up everything and resets
|
|
|
1563 *
|
|
|
1564 * Print: prints the tags
|
|
|
1565 */
|
|
|
1566 static char *
|
|
|
1567 cs_manage_matches(matches, contexts, totmatches, cmd)
|
|
|
1568 char **matches;
|
|
|
1569 char **contexts;
|
|
|
1570 int totmatches;
|
|
|
1571 mcmd_e cmd;
|
|
|
1572 {
|
|
|
1573 static char **mp = NULL;
|
|
|
1574 static char **cp = NULL;
|
|
|
1575 static int cnt = -1;
|
|
|
1576 static int next = -1;
|
|
|
1577 char *p = NULL;
|
|
|
1578
|
|
|
1579 switch (cmd)
|
|
|
1580 {
|
|
|
1581 case Store:
|
|
|
1582 assert(matches != NULL);
|
|
|
1583 assert(totmatches > 0);
|
|
|
1584 if (mp != NULL || cp != NULL)
|
|
|
1585 (void)cs_manage_matches(NULL, NULL, -1, Free);
|
|
|
1586 mp = matches;
|
|
|
1587 cp = contexts;
|
|
|
1588 cnt = totmatches;
|
|
|
1589 next = 0;
|
|
|
1590 break;
|
|
|
1591 case Get:
|
|
|
1592 if (next >= cnt)
|
|
|
1593 return NULL;
|
|
|
1594
|
|
|
1595 p = mp[next];
|
|
|
1596 next++;
|
|
|
1597 break;
|
|
|
1598 case Free:
|
|
|
1599 if (mp != NULL)
|
|
|
1600 {
|
|
|
1601 if (cnt > 0)
|
|
|
1602 while (cnt--)
|
|
|
1603 {
|
|
|
1604 vim_free(mp[cnt]);
|
|
|
1605 if (cp != NULL)
|
|
|
1606 vim_free(cp[cnt]);
|
|
|
1607 }
|
|
|
1608 vim_free(mp);
|
|
|
1609 vim_free(cp);
|
|
|
1610 }
|
|
|
1611 mp = NULL;
|
|
|
1612 cp = NULL;
|
|
|
1613 cnt = 0;
|
|
|
1614 next = 0;
|
|
|
1615 break;
|
|
|
1616 case Print:
|
|
|
1617 cs_print_tags_priv(mp, cp, cnt);
|
|
|
1618 break;
|
|
|
1619 default: /* should not reach here */
|
|
|
1620 (void)EMSG(_("E570: fatal error in cs_manage_matches"));
|
|
|
1621 return NULL;
|
|
|
1622 }
|
|
|
1623
|
|
|
1624 return p;
|
|
|
1625 } /* cs_manage_matches */
|
|
|
1626
|
|
|
1627
|
|
|
1628 /*
|
|
|
1629 * PRIVATE: cs_parse_results
|
|
|
1630 *
|
|
|
1631 * parse cscope output
|
|
|
1632 */
|
|
|
1633 static char *
|
|
|
1634 cs_parse_results(cnumber, buf, bufsize, context, linenumber, search)
|
|
|
1635 int cnumber;
|
|
|
1636 char *buf;
|
|
|
1637 int bufsize;
|
|
|
1638 char **context;
|
|
|
1639 char **linenumber;
|
|
|
1640 char **search;
|
|
|
1641 {
|
|
|
1642 int ch;
|
|
|
1643 char *p;
|
|
|
1644 char *name;
|
|
|
1645
|
|
|
1646 if (fgets(buf, bufsize, csinfo[cnumber].fr_fp) == NULL)
|
|
|
1647 {
|
|
|
1648 if (feof(csinfo[cnumber].fr_fp))
|
|
|
1649 errno = EIO;
|
|
|
1650
|
|
|
1651 cs_reading_emsg(cnumber);
|
|
|
1652
|
|
|
1653 return NULL;
|
|
|
1654 }
|
|
|
1655
|
|
|
1656 /* If the line's too long for the buffer, discard it. */
|
|
|
1657 if ((p = strchr(buf, '\n')) == NULL)
|
|
|
1658 {
|
|
|
1659 while ((ch = getc(csinfo[cnumber].fr_fp)) != EOF && ch != '\n')
|
|
|
1660 ;
|
|
|
1661 return NULL;
|
|
|
1662 }
|
|
|
1663 *p = '\0';
|
|
|
1664
|
|
|
1665 /*
|
|
|
1666 * cscope output is in the following format:
|
|
|
1667 *
|
|
|
1668 * <filename> <context> <line number> <pattern>
|
|
|
1669 */
|
|
|
1670 if ((name = strtok((char *)buf, (const char *)" ")) == NULL)
|
|
|
1671 return NULL;
|
|
|
1672 if ((*context = strtok(NULL, (const char *)" ")) == NULL)
|
|
|
1673 return NULL;
|
|
|
1674 if ((*linenumber = strtok(NULL, (const char *)" ")) == NULL)
|
|
|
1675 return NULL;
|
|
|
1676 *search = *linenumber + strlen(*linenumber) + 1; /* +1 to skip \0 */
|
|
|
1677
|
|
|
1678 /* --- nvi ---
|
|
|
1679 * If the file is older than the cscope database, that is,
|
|
|
1680 * the database was built since the file was last modified,
|
|
|
1681 * or there wasn't a search string, use the line number.
|
|
|
1682 */
|
|
|
1683 if (strcmp(*search, "<unknown>") == 0)
|
|
|
1684 *search = NULL;
|
|
|
1685
|
|
|
1686 name = cs_resolve_file(cnumber, name);
|
|
|
1687 return name;
|
|
|
1688 }
|
|
|
1689
|
|
636
|
1690 #ifdef FEAT_QUICKFIX
|
|
7
|
1691 /*
|
|
|
1692 * PRIVATE: cs_file_results
|
|
|
1693 *
|
|
|
1694 * write cscope find results to file
|
|
|
1695 */
|
|
|
1696 static void
|
|
|
1697 cs_file_results(f, nummatches_a)
|
|
|
1698 FILE *f;
|
|
|
1699 int *nummatches_a;
|
|
|
1700 {
|
|
|
1701 int i, j;
|
|
|
1702 char *buf;
|
|
|
1703 char *search, *slno;
|
|
|
1704 char *fullname;
|
|
|
1705 char *cntx;
|
|
|
1706 char *context;
|
|
|
1707
|
|
|
1708 buf = (char *)alloc(CSREAD_BUFSIZE);
|
|
|
1709 if (buf == NULL)
|
|
|
1710 return;
|
|
|
1711
|
|
|
1712 for (i = 0; i < CSCOPE_MAX_CONNECTIONS; i++)
|
|
|
1713 {
|
|
|
1714 if (nummatches_a[i] < 1)
|
|
|
1715 continue;
|
|
|
1716
|
|
|
1717 for (j = 0; j < nummatches_a[i]; j++)
|
|
|
1718 {
|
|
293
|
1719 if ((fullname = cs_parse_results(i, buf, CSREAD_BUFSIZE, &cntx,
|
|
|
1720 &slno, &search)) == NULL)
|
|
7
|
1721 continue;
|
|
|
1722
|
|
|
1723 context = (char *)alloc(strlen(cntx)+5);
|
|
|
1724 if (context==NULL)
|
|
|
1725 continue;
|
|
|
1726
|
|
|
1727 if (strcmp(cntx, "<global>")==0)
|
|
|
1728 strcpy(context, "<<global>>");
|
|
|
1729 else
|
|
|
1730 sprintf(context, "<<%s>>", cntx);
|
|
|
1731
|
|
|
1732 if (search==NULL)
|
|
|
1733 fprintf(f, "%s\t%s\t%s\n", fullname, slno, context);
|
|
|
1734 else
|
|
|
1735 fprintf(f, "%s\t%s\t%s %s\n", fullname, slno, context, search);
|
|
|
1736
|
|
|
1737 vim_free(context);
|
|
|
1738 vim_free(fullname);
|
|
|
1739 } /* for all matches */
|
|
|
1740
|
|
|
1741 (void)cs_read_prompt(i);
|
|
|
1742
|
|
|
1743 } /* for all cscope connections */
|
|
|
1744 vim_free(buf);
|
|
|
1745 }
|
|
636
|
1746 #endif
|
|
7
|
1747
|
|
|
1748 /*
|
|
|
1749 * PRIVATE: cs_fill_results
|
|
|
1750 *
|
|
|
1751 * get parsed cscope output and calls cs_make_vim_style_matches to convert
|
|
|
1752 * into ctags format
|
|
297
|
1753 * When there are no matches sets "*matches_p" to NULL.
|
|
7
|
1754 */
|
|
|
1755 static void
|
|
|
1756 cs_fill_results(tagstr, totmatches, nummatches_a, matches_p, cntxts_p, matched)
|
|
|
1757 char *tagstr;
|
|
|
1758 int totmatches;
|
|
|
1759 int *nummatches_a;
|
|
|
1760 char ***matches_p;
|
|
|
1761 char ***cntxts_p;
|
|
|
1762 int *matched;
|
|
|
1763 {
|
|
|
1764 int i, j;
|
|
|
1765 char *buf;
|
|
|
1766 char *search, *slno;
|
|
|
1767 int totsofar = 0;
|
|
|
1768 char **matches = NULL;
|
|
|
1769 char **cntxts = NULL;
|
|
|
1770 char *fullname;
|
|
|
1771 char *cntx;
|
|
|
1772
|
|
|
1773 assert(totmatches > 0);
|
|
|
1774
|
|
|
1775 buf = (char *)alloc(CSREAD_BUFSIZE);
|
|
|
1776 if (buf == NULL)
|
|
|
1777 return;
|
|
|
1778
|
|
|
1779 if ((matches = (char **)alloc(sizeof(char *) * totmatches)) == NULL)
|
|
|
1780 goto parse_out;
|
|
|
1781 if ((cntxts = (char **)alloc(sizeof(char *) * totmatches)) == NULL)
|
|
|
1782 goto parse_out;
|
|
|
1783
|
|
|
1784 for (i = 0; i < CSCOPE_MAX_CONNECTIONS; i++)
|
|
|
1785 {
|
|
|
1786 if (nummatches_a[i] < 1)
|
|
|
1787 continue;
|
|
|
1788
|
|
|
1789 for (j = 0; j < nummatches_a[i]; j++)
|
|
|
1790 {
|
|
|
1791 if ((fullname = cs_parse_results(i, buf, CSREAD_BUFSIZE, &cntx,
|
|
|
1792 &slno, &search)) == NULL)
|
|
|
1793 continue;
|
|
|
1794
|
|
|
1795 matches[totsofar] = cs_make_vim_style_matches(fullname, slno,
|
|
|
1796 search, tagstr);
|
|
|
1797
|
|
|
1798 vim_free(fullname);
|
|
|
1799
|
|
|
1800 if (strcmp(cntx, "<global>") == 0)
|
|
|
1801 cntxts[totsofar] = NULL;
|
|
|
1802 else
|
|
|
1803 /* note: if vim_strsave returns NULL, then the context
|
|
|
1804 * will be "<global>", which is misleading.
|
|
|
1805 */
|
|
|
1806 cntxts[totsofar] = (char *)vim_strsave((char_u *)cntx);
|
|
|
1807
|
|
|
1808 if (matches[totsofar] != NULL)
|
|
|
1809 totsofar++;
|
|
|
1810
|
|
|
1811 } /* for all matches */
|
|
|
1812
|
|
|
1813 (void)cs_read_prompt(i);
|
|
|
1814
|
|
|
1815 } /* for all cscope connections */
|
|
|
1816
|
|
|
1817 parse_out:
|
|
297
|
1818 if (totsofar == 0)
|
|
|
1819 {
|
|
|
1820 /* No matches, free the arrays and return NULL in "*matches_p". */
|
|
|
1821 vim_free(matches);
|
|
|
1822 matches = NULL;
|
|
|
1823 vim_free(cntxts);
|
|
|
1824 cntxts = NULL;
|
|
|
1825 }
|
|
7
|
1826 *matched = totsofar;
|
|
|
1827 *matches_p = matches;
|
|
|
1828 *cntxts_p = cntxts;
|
|
297
|
1829
|
|
7
|
1830 vim_free(buf);
|
|
|
1831 } /* cs_fill_results */
|
|
|
1832
|
|
|
1833
|
|
|
1834 /* get the requested path components */
|
|
|
1835 static char *
|
|
|
1836 cs_pathcomponents(path)
|
|
|
1837 char *path;
|
|
|
1838 {
|
|
|
1839 int i;
|
|
|
1840 char *s;
|
|
|
1841
|
|
|
1842 if (p_cspc == 0)
|
|
|
1843 return path;
|
|
|
1844
|
|
|
1845 s = path + strlen(path) - 1;
|
|
|
1846 for (i = 0; i < p_cspc; ++i)
|
|
|
1847 while (s > path && *--s != '/'
|
|
|
1848 #ifdef WIN32
|
|
|
1849 && *--s != '\\'
|
|
|
1850 #endif
|
|
|
1851 )
|
|
|
1852 ;
|
|
|
1853 if ((s > path && *s == '/')
|
|
|
1854 #ifdef WIN32
|
|
|
1855 || (s > path && *s == '\\')
|
|
|
1856 #endif
|
|
|
1857 )
|
|
|
1858 ++s;
|
|
|
1859 return s;
|
|
|
1860 }
|
|
|
1861
|
|
|
1862 /*
|
|
|
1863 * PRIVATE: cs_print_tags_priv
|
|
|
1864 *
|
|
|
1865 * called from cs_manage_matches()
|
|
|
1866 */
|
|
|
1867 static void
|
|
|
1868 cs_print_tags_priv(matches, cntxts, num_matches)
|
|
|
1869 char **matches;
|
|
|
1870 char **cntxts;
|
|
|
1871 int num_matches;
|
|
|
1872 {
|
|
|
1873 char *buf = NULL;
|
|
|
1874 int bufsize = 0; /* Track available bufsize */
|
|
|
1875 int newsize = 0;
|
|
|
1876 char *ptag;
|
|
|
1877 char *fname, *lno, *extra, *tbuf;
|
|
|
1878 int i, idx, num;
|
|
|
1879 char *globalcntx = "GLOBAL";
|
|
|
1880 char *cntxformat = " <<%s>>";
|
|
|
1881 char *context;
|
|
|
1882 char *cstag_msg = _("Cscope tag: %s");
|
|
|
1883 char *csfmt_str = "%4d %6s ";
|
|
|
1884
|
|
|
1885 assert (num_matches > 0);
|
|
|
1886
|
|
|
1887 if ((tbuf = (char *)alloc(strlen(matches[0]) + 1)) == NULL)
|
|
|
1888 return;
|
|
|
1889
|
|
|
1890 strcpy(tbuf, matches[0]);
|
|
|
1891 ptag = strtok(tbuf, "\t");
|
|
|
1892
|
|
|
1893 newsize = strlen(cstag_msg) + strlen(ptag);
|
|
|
1894 buf = (char *)alloc(newsize);
|
|
|
1895 if (buf != NULL)
|
|
|
1896 {
|
|
|
1897 bufsize = newsize;
|
|
|
1898 (void)sprintf(buf, cstag_msg, ptag);
|
|
|
1899 MSG_PUTS_ATTR(buf, hl_attr(HLF_T));
|
|
|
1900 }
|
|
|
1901
|
|
|
1902 vim_free(tbuf);
|
|
|
1903
|
|
|
1904 MSG_PUTS_ATTR(_("\n # line"), hl_attr(HLF_T)); /* strlen is 7 */
|
|
|
1905 msg_advance(msg_col + 2);
|
|
|
1906 MSG_PUTS_ATTR(_("filename / context / line\n"), hl_attr(HLF_T));
|
|
|
1907
|
|
|
1908 num = 1;
|
|
|
1909 for (i = 0; i < num_matches; i++)
|
|
|
1910 {
|
|
|
1911 idx = i;
|
|
|
1912
|
|
|
1913 /* if we really wanted to, we could avoid this malloc and strcpy
|
|
|
1914 * by parsing matches[i] on the fly and placing stuff into buf
|
|
|
1915 * directly, but that's too much of a hassle
|
|
|
1916 */
|
|
|
1917 if ((tbuf = (char *)alloc(strlen(matches[idx]) + 1)) == NULL)
|
|
|
1918 continue;
|
|
|
1919 (void)strcpy(tbuf, matches[idx]);
|
|
|
1920
|
|
|
1921 if ((fname = strtok(tbuf, (const char *)"\t")) == NULL)
|
|
|
1922 continue;
|
|
|
1923 if ((fname = strtok(NULL, (const char *)"\t")) == NULL)
|
|
|
1924 continue;
|
|
|
1925 if ((lno = strtok(NULL, (const char *)"\t")) == NULL)
|
|
|
1926 {
|
|
|
1927 /* if NULL, then no "extra", although in cscope's case, there
|
|
|
1928 * should always be "extra".
|
|
|
1929 */
|
|
|
1930 extra = NULL;
|
|
|
1931 }
|
|
|
1932
|
|
|
1933 extra = lno + strlen(lno) + 1;
|
|
|
1934
|
|
|
1935 lno[strlen(lno)-2] = '\0'; /* ignore ;" at the end */
|
|
|
1936
|
|
|
1937 /* hopefully 'num' (num of matches) will be less than 10^16 */
|
|
|
1938 newsize = strlen(csfmt_str) + 16 + strlen(lno);
|
|
|
1939 if (bufsize < newsize)
|
|
|
1940 {
|
|
|
1941 buf = (char *)vim_realloc(buf, newsize);
|
|
|
1942 if (buf == NULL)
|
|
|
1943 bufsize = 0;
|
|
|
1944 else
|
|
|
1945 bufsize = newsize;
|
|
|
1946 }
|
|
|
1947 if (buf != NULL)
|
|
|
1948 {
|
|
|
1949 /* csfmt_str = "%4d %6s "; */
|
|
|
1950 (void)sprintf(buf, csfmt_str, num, lno);
|
|
|
1951 MSG_PUTS_ATTR(buf, hl_attr(HLF_CM));
|
|
|
1952 }
|
|
|
1953 MSG_PUTS_LONG_ATTR(cs_pathcomponents(fname), hl_attr(HLF_CM));
|
|
|
1954
|
|
|
1955 /* compute the required space for the context */
|
|
|
1956 if (cntxts[idx] != NULL)
|
|
|
1957 context = cntxts[idx];
|
|
|
1958 else
|
|
|
1959 context = globalcntx;
|
|
|
1960 newsize = strlen(context) + strlen(cntxformat);
|
|
|
1961
|
|
|
1962 if (bufsize < newsize)
|
|
|
1963 {
|
|
|
1964 buf = (char *)vim_realloc(buf, newsize);
|
|
|
1965 if (buf == NULL)
|
|
|
1966 bufsize = 0;
|
|
|
1967 else
|
|
|
1968 bufsize = newsize;
|
|
|
1969 }
|
|
|
1970 if (buf != NULL)
|
|
|
1971 {
|
|
|
1972 (void)sprintf(buf, cntxformat, context);
|
|
|
1973
|
|
|
1974 /* print the context only if it fits on the same line */
|
|
|
1975 if (msg_col + (int)strlen(buf) >= (int)Columns)
|
|
|
1976 msg_putchar('\n');
|
|
|
1977 msg_advance(12);
|
|
|
1978 MSG_PUTS_LONG(buf);
|
|
|
1979 msg_putchar('\n');
|
|
|
1980 }
|
|
|
1981 if (extra != NULL)
|
|
|
1982 {
|
|
|
1983 msg_advance(13);
|
|
|
1984 MSG_PUTS_LONG(extra);
|
|
|
1985 }
|
|
|
1986
|
|
|
1987 vim_free(tbuf); /* only after printing extra due to strtok use */
|
|
|
1988
|
|
|
1989 if (msg_col)
|
|
|
1990 msg_putchar('\n');
|
|
|
1991
|
|
|
1992 ui_breakcheck();
|
|
|
1993 if (got_int)
|
|
|
1994 {
|
|
|
1995 got_int = FALSE; /* don't print any more matches */
|
|
|
1996 break;
|
|
|
1997 }
|
|
|
1998
|
|
|
1999 num++;
|
|
|
2000 } /* for all matches */
|
|
|
2001
|
|
|
2002 vim_free(buf);
|
|
|
2003 } /* cs_print_tags_priv */
|
|
|
2004
|
|
|
2005
|
|
|
2006 /*
|
|
|
2007 * PRIVATE: cs_read_prompt
|
|
|
2008 *
|
|
|
2009 * read a cscope prompt (basically, skip over the ">> ")
|
|
|
2010 */
|
|
|
2011 static int
|
|
|
2012 cs_read_prompt(i)
|
|
|
2013 int i;
|
|
|
2014 {
|
|
|
2015 int ch;
|
|
|
2016 char *buf = NULL; /* buffer for possible error message from cscope */
|
|
|
2017 int bufpos = 0;
|
|
|
2018 char *cs_emsg;
|
|
|
2019 int maxlen;
|
|
|
2020 static char *eprompt = "Press the RETURN key to continue:";
|
|
|
2021 int epromptlen = strlen(eprompt);
|
|
|
2022 int n;
|
|
|
2023
|
|
|
2024 cs_emsg = _("E609: Cscope error: %s");
|
|
|
2025 /* compute maximum allowed len for Cscope error message */
|
|
|
2026 maxlen = (int)(IOSIZE - strlen(cs_emsg));
|
|
|
2027
|
|
|
2028 for (;;)
|
|
|
2029 {
|
|
|
2030 while ((ch = getc(csinfo[i].fr_fp)) != EOF && ch != CSCOPE_PROMPT[0])
|
|
|
2031 /* if there is room and char is printable */
|
|
|
2032 if (bufpos < maxlen - 1 && vim_isprintc(ch))
|
|
|
2033 {
|
|
|
2034 if (buf == NULL) /* lazy buffer allocation */
|
|
|
2035 buf = (char *)alloc(maxlen);
|
|
|
2036 if (buf != NULL)
|
|
|
2037 {
|
|
|
2038 /* append character to the message */
|
|
|
2039 buf[bufpos++] = ch;
|
|
|
2040 buf[bufpos] = NUL;
|
|
|
2041 if (bufpos >= epromptlen
|
|
|
2042 && strcmp(&buf[bufpos - epromptlen], eprompt) == 0)
|
|
|
2043 {
|
|
|
2044 /* remove eprompt from buf */
|
|
|
2045 buf[bufpos - epromptlen] = NUL;
|
|
|
2046
|
|
|
2047 /* print message to user */
|
|
|
2048 (void)EMSG2(cs_emsg, buf);
|
|
|
2049
|
|
|
2050 /* send RETURN to cscope */
|
|
|
2051 (void)putc('\n', csinfo[i].to_fp);
|
|
|
2052 (void)fflush(csinfo[i].to_fp);
|
|
|
2053
|
|
|
2054 /* clear buf */
|
|
|
2055 bufpos = 0;
|
|
|
2056 buf[bufpos] = NUL;
|
|
|
2057 }
|
|
|
2058 }
|
|
|
2059 }
|
|
|
2060
|
|
|
2061 for (n = 0; n < (int)strlen(CSCOPE_PROMPT); ++n)
|
|
|
2062 {
|
|
|
2063 if (n > 0)
|
|
|
2064 ch = getc(csinfo[i].fr_fp);
|
|
|
2065 if (ch == EOF)
|
|
|
2066 {
|
|
|
2067 PERROR("cs_read_prompt EOF");
|
|
|
2068 if (buf != NULL && buf[0] != NUL)
|
|
|
2069 (void)EMSG2(cs_emsg, buf);
|
|
|
2070 else if (p_csverbose)
|
|
|
2071 cs_reading_emsg(i); /* don't have additional information */
|
|
|
2072 cs_release_csp(i, TRUE);
|
|
|
2073 vim_free(buf);
|
|
|
2074 return CSCOPE_FAILURE;
|
|
|
2075 }
|
|
|
2076
|
|
|
2077 if (ch != CSCOPE_PROMPT[n])
|
|
|
2078 {
|
|
|
2079 ch = EOF;
|
|
|
2080 break;
|
|
|
2081 }
|
|
|
2082 }
|
|
|
2083
|
|
|
2084 if (ch == EOF)
|
|
|
2085 continue; /* didn't find the prompt */
|
|
|
2086 break; /* did find the prompt */
|
|
|
2087 }
|
|
|
2088
|
|
|
2089 vim_free(buf);
|
|
|
2090 return CSCOPE_SUCCESS;
|
|
|
2091 }
|
|
|
2092
|
|
|
2093
|
|
|
2094 /*
|
|
|
2095 * PRIVATE: cs_release_csp
|
|
|
2096 *
|
|
|
2097 * does the actual free'ing for the cs ptr with an optional flag of whether
|
|
|
2098 * or not to free the filename. called by cs_kill and cs_reset.
|
|
|
2099 */
|
|
|
2100 static void
|
|
|
2101 cs_release_csp(i, freefnpp)
|
|
|
2102 int i;
|
|
|
2103 int freefnpp;
|
|
|
2104 {
|
|
|
2105 #if defined(UNIX)
|
|
|
2106 int pstat;
|
|
|
2107 #else
|
|
|
2108 /*
|
|
|
2109 * Trying to exit normally (not sure whether it is fit to UNIX cscope
|
|
|
2110 */
|
|
|
2111 if (csinfo[i].to_fp != NULL)
|
|
|
2112 {
|
|
|
2113 (void)fputs("q\n", csinfo[i].to_fp);
|
|
|
2114 (void)fflush(csinfo[i].to_fp);
|
|
|
2115 }
|
|
|
2116 /* give cscope chance to exit normally */
|
|
301
|
2117 if (csinfo[i].hProc != NULL
|
|
7
|
2118 && WaitForSingleObject(csinfo[i].hProc, 1000) == WAIT_TIMEOUT)
|
|
|
2119 TerminateProcess(csinfo[i].hProc, 0);
|
|
|
2120 #endif
|
|
|
2121
|
|
|
2122 if (csinfo[i].fr_fp != NULL)
|
|
|
2123 (void)fclose(csinfo[i].fr_fp);
|
|
|
2124 if (csinfo[i].to_fp != NULL)
|
|
|
2125 (void)fclose(csinfo[i].to_fp);
|
|
|
2126
|
|
|
2127 /*
|
|
|
2128 * Safety check: If the PID would be zero here, the entire X session would
|
|
|
2129 * be killed. -1 and 1 are dangerous as well.
|
|
|
2130 */
|
|
|
2131 #if defined(UNIX)
|
|
|
2132 if (csinfo[i].pid > 1)
|
|
|
2133 {
|
|
|
2134 kill(csinfo[i].pid, SIGTERM);
|
|
|
2135 (void)waitpid(csinfo[i].pid, &pstat, 0);
|
|
|
2136 }
|
|
|
2137 #endif
|
|
|
2138
|
|
|
2139 if (freefnpp)
|
|
|
2140 {
|
|
|
2141 vim_free(csinfo[i].fname);
|
|
|
2142 vim_free(csinfo[i].ppath);
|
|
|
2143 vim_free(csinfo[i].flags);
|
|
|
2144 }
|
|
|
2145
|
|
|
2146 clear_csinfo(i);
|
|
|
2147 } /* cs_release_csp */
|
|
|
2148
|
|
|
2149
|
|
|
2150 /*
|
|
|
2151 * PRIVATE: cs_reset
|
|
|
2152 *
|
|
|
2153 * calls cs_kill on all cscope connections then reinits
|
|
|
2154 */
|
|
|
2155 /* ARGSUSED */
|
|
|
2156 static int
|
|
|
2157 cs_reset(eap)
|
|
|
2158 exarg_T *eap;
|
|
|
2159 {
|
|
|
2160 char **dblist = NULL, **pplist = NULL, **fllist = NULL;
|
|
|
2161 int i;
|
|
273
|
2162 char buf[20]; /* for sprintf " (#%d)" */
|
|
7
|
2163
|
|
|
2164 /* malloc our db and ppath list */
|
|
|
2165 dblist = (char **)alloc(CSCOPE_MAX_CONNECTIONS * sizeof(char *));
|
|
|
2166 pplist = (char **)alloc(CSCOPE_MAX_CONNECTIONS * sizeof(char *));
|
|
|
2167 fllist = (char **)alloc(CSCOPE_MAX_CONNECTIONS * sizeof(char *));
|
|
|
2168 if (dblist == NULL || pplist == NULL || fllist == NULL)
|
|
|
2169 {
|
|
|
2170 vim_free(dblist);
|
|
|
2171 vim_free(pplist);
|
|
|
2172 vim_free(fllist);
|
|
|
2173 return CSCOPE_FAILURE;
|
|
|
2174 }
|
|
|
2175
|
|
|
2176 for (i = 0; i < CSCOPE_MAX_CONNECTIONS; i++)
|
|
|
2177 {
|
|
|
2178 dblist[i] = csinfo[i].fname;
|
|
|
2179 pplist[i] = csinfo[i].ppath;
|
|
|
2180 fllist[i] = csinfo[i].flags;
|
|
|
2181 if (csinfo[i].fname != NULL)
|
|
|
2182 cs_release_csp(i, FALSE);
|
|
|
2183 }
|
|
|
2184
|
|
|
2185 /* rebuild the cscope connection list */
|
|
|
2186 for (i = 0; i < CSCOPE_MAX_CONNECTIONS; i++)
|
|
|
2187 {
|
|
|
2188 if (dblist[i] != NULL)
|
|
|
2189 {
|
|
|
2190 cs_add_common(dblist[i], pplist[i], fllist[i]);
|
|
|
2191 if (p_csverbose)
|
|
|
2192 {
|
|
|
2193 /* dont' use smsg_attr because want to display
|
|
|
2194 * connection number in the same line as
|
|
|
2195 * "Added cscope database..."
|
|
|
2196 */
|
|
|
2197 sprintf(buf, " (#%d)", i);
|
|
|
2198 MSG_PUTS_ATTR(buf, hl_attr(HLF_R));
|
|
|
2199 }
|
|
|
2200 }
|
|
|
2201 vim_free(dblist[i]);
|
|
|
2202 vim_free(pplist[i]);
|
|
|
2203 vim_free(fllist[i]);
|
|
|
2204 }
|
|
|
2205 vim_free(dblist);
|
|
|
2206 vim_free(pplist);
|
|
|
2207 vim_free(fllist);
|
|
|
2208
|
|
|
2209 if (p_csverbose)
|
|
|
2210 MSG_ATTR(_("All cscope databases reset"), hl_attr(HLF_R) | MSG_HIST);
|
|
|
2211 return CSCOPE_SUCCESS;
|
|
|
2212 } /* cs_reset */
|
|
|
2213
|
|
|
2214
|
|
|
2215 /*
|
|
|
2216 * PRIVATE: cs_resolve_file
|
|
|
2217 *
|
|
|
2218 * construct the full pathname to a file found in the cscope database.
|
|
|
2219 * (Prepends ppath, if there is one and if it's not already prepended,
|
|
|
2220 * otherwise just uses the name found.)
|
|
|
2221 *
|
|
|
2222 * we need to prepend the prefix because on some cscope's (e.g., the one that
|
|
|
2223 * ships with Solaris 2.6), the output never has the prefix prepended.
|
|
|
2224 * contrast this with my development system (Digital Unix), which does.
|
|
|
2225 */
|
|
|
2226 static char *
|
|
|
2227 cs_resolve_file(i, name)
|
|
|
2228 int i;
|
|
|
2229 char *name;
|
|
|
2230 {
|
|
|
2231 char *fullname;
|
|
|
2232 int len;
|
|
|
2233
|
|
|
2234 /*
|
|
|
2235 * ppath is freed when we destroy the cscope connection.
|
|
|
2236 * fullname is freed after cs_make_vim_style_matches, after it's been
|
|
|
2237 * copied into the tag buffer used by vim
|
|
|
2238 */
|
|
|
2239 len = strlen(name) + 2;
|
|
|
2240 if (csinfo[i].ppath != NULL)
|
|
|
2241 len += strlen(csinfo[i].ppath);
|
|
|
2242
|
|
|
2243 if ((fullname = (char *)alloc(len)) == NULL)
|
|
|
2244 return NULL;
|
|
|
2245
|
|
|
2246 /*
|
|
|
2247 * note/example: this won't work if the cscope output already starts
|
|
|
2248 * "../.." and the prefix path is also "../..". if something like this
|
|
|
2249 * happens, you are screwed up and need to fix how you're using cscope.
|
|
|
2250 */
|
|
|
2251 if (csinfo[i].ppath != NULL &&
|
|
|
2252 (strncmp(name, csinfo[i].ppath, strlen(csinfo[i].ppath)) != 0) &&
|
|
|
2253 (name[0] != '/')
|
|
|
2254 #ifdef WIN32
|
|
|
2255 && name[0] != '\\' && name[1] != ':'
|
|
|
2256 #endif
|
|
|
2257 )
|
|
|
2258 (void)sprintf(fullname, "%s/%s", csinfo[i].ppath, name);
|
|
|
2259 else
|
|
|
2260 (void)sprintf(fullname, "%s", name);
|
|
|
2261
|
|
|
2262 return fullname;
|
|
|
2263 } /* cs_resolve_file */
|
|
|
2264
|
|
|
2265
|
|
|
2266 /*
|
|
|
2267 * PRIVATE: cs_show
|
|
|
2268 *
|
|
|
2269 * show all cscope connections
|
|
|
2270 */
|
|
|
2271 /* ARGSUSED */
|
|
|
2272 static int
|
|
|
2273 cs_show(eap)
|
|
|
2274 exarg_T *eap;
|
|
|
2275 {
|
|
|
2276 short i;
|
|
|
2277 if (cs_cnt_connections() == 0)
|
|
|
2278 MSG_PUTS(_("no cscope connections\n"));
|
|
|
2279 else
|
|
|
2280 {
|
|
|
2281 MSG_PUTS_ATTR(
|
|
|
2282 _(" # pid database name prepend path\n"),
|
|
|
2283 hl_attr(HLF_T));
|
|
|
2284 for (i = 0; i < CSCOPE_MAX_CONNECTIONS; i++)
|
|
|
2285 {
|
|
|
2286 if (csinfo[i].fname == NULL)
|
|
|
2287 continue;
|
|
|
2288
|
|
|
2289 if (csinfo[i].ppath != NULL)
|
|
|
2290 (void)smsg((char_u *)"%2d %-5ld %-34s %-32s",
|
|
|
2291 i, (long)csinfo[i].pid, csinfo[i].fname, csinfo[i].ppath);
|
|
|
2292 else
|
|
|
2293 (void)smsg((char_u *)"%2d %-5ld %-34s <none>",
|
|
|
2294 i, (long)csinfo[i].pid, csinfo[i].fname);
|
|
|
2295 }
|
|
|
2296 }
|
|
|
2297
|
|
|
2298 wait_return(TRUE);
|
|
|
2299 return CSCOPE_SUCCESS;
|
|
|
2300 } /* cs_show */
|
|
|
2301
|
|
|
2302 #endif /* FEAT_CSCOPE */
|
|
|
2303
|
|
|
2304 /* the end */
|
