src/if_cscope.c

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