/[global]/global/libutil/gtagsop.c
ViewVC logotype

Diff of /global/libutil/gtagsop.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.14 by shigio, Wed Oct 10 15:48:41 2001 UTC revision 1.15 by shigio, Fri Oct 26 07:47:44 2001 UTC
# Line 197  int    flags; Line 197  int    flags;
197          return 0;          return 0;
198  }  }
199  /*  /*
200     * gtags_setinfo: set info string.
201     *
202     *      i)      info    info string
203     *
204     * Currently this method is used for postgres.
205     */
206    void
207    gtags_setinfo(info)
208    char *info;
209    {
210            dbop_setinfo(info);
211    }
212    /*
213   * gtags_open: open global tag.   * gtags_open: open global tag.
214   *   *
215   *      i)      dbpath  dbpath directory   *      i)      dbpath  dbpath directory
# Line 207  int    flags; Line 220  int    flags;
220   *                      GTAGS_MODIFY: modify tag   *                      GTAGS_MODIFY: modify tag
221   *      i)      flags   GTAGS_COMPACT   *      i)      flags   GTAGS_COMPACT
222   *                      GTAGS_PATHINDEX   *                      GTAGS_PATHINDEX
223     *                      GTAGS_POSTGRES
224   *      r)              GTOP structure   *      r)              GTOP structure
225   *   *
226   * when error occurred, gtagopen doesn't return.   * when error occurred, gtagopen doesn't return.
# Line 221  int    mode; Line 235  int    mode;
235  int     flags;  int     flags;
236  {  {
237          GTOP    *gtop;          GTOP    *gtop;
238            char    *path;
239          int     dbmode = 0;          int     dbmode = 0;
240            int     dbopflags = 0;
241    
242          /* initialize for isregex() */          /* initialize for isregex() */
243          if (!init) {          if (!init) {
# Line 234  int    flags; Line 250  int    flags;
250                  die("short of memory.");                  die("short of memory.");
251          gtop->db = db;          gtop->db = db;
252          gtop->mode = mode;          gtop->mode = mode;
253            gtop->openflags = flags;
254          switch (gtop->mode) {          switch (gtop->mode) {
255          case GTAGS_READ:          case GTAGS_READ:
256                  dbmode = 0;                  dbmode = 0;
# Line 251  int    flags; Line 268  int    flags;
268          /*          /*
269           * allow duplicate records.           * allow duplicate records.
270           */           */
271          gtop->dbop = dbop_open(makepath(dbpath, dbname(db), NULL), dbmode, 0644, DBOP_DUP);          dbopflags = DBOP_DUP;
272            if (flags & GTAGS_POSTGRES)
273                    dbopflags |= DBOP_POSTGRES;
274            path = strdup(makepath(dbpath, dbname(db), NULL));
275            if (path == NULL)
276                    die("short of memory.");
277            gtop->dbop = dbop_open(path, dbmode, 0644, dbopflags);
278            free(path);
279          if (gtop->dbop == NULL) {          if (gtop->dbop == NULL) {
280                  if (dbmode == 1)                  if (dbmode == 1)
281                          die("cannot make %s.", dbname(db));                          die("cannot make %s.", dbname(db));
282                  die("%s not found.", dbname(db));                  die("%s not found.", dbname(db));
283          }          }
284            if (gtop->dbop->openflags & DBOP_POSTGRES)
285                    gtop->openflags |= GTAGS_POSTGRES;
286          /*          /*
287           * decide format version.           * decide format version.
288           */           */
# Line 275  int    flags; Line 301  int    flags;
301                          gtop->format_version = 2;                          gtop->format_version = 2;
302                          snprintf(buf, sizeof(buf),                          snprintf(buf, sizeof(buf),
303                                  "%s %d", VERSIONKEY, gtop->format_version);                                  "%s %d", VERSIONKEY, gtop->format_version);
304                          dbop_put(gtop->dbop, VERSIONKEY, buf, 0);                          dbop_put(gtop->dbop, VERSIONKEY, buf, "0");
305                          gtop->format |= GTAGS_COMPACT;                          gtop->format |= GTAGS_COMPACT;
306                          dbop_put(gtop->dbop, COMPACTKEY, COMPACTKEY, 0);                          dbop_put(gtop->dbop, COMPACTKEY, COMPACTKEY, "0");
307                          if (flags & GTAGS_PATHINDEX) {                          if (flags & GTAGS_PATHINDEX) {
308                                  gtop->format |= GTAGS_PATHINDEX;                                  gtop->format |= GTAGS_PATHINDEX;
309                                  dbop_put(gtop->dbop, PATHINDEXKEY, PATHINDEXKEY, 0);                                  dbop_put(gtop->dbop, PATHINDEXKEY, PATHINDEXKEY, "0");
310                          }                          }
311                  }                  }
312          } else {          } else {
# Line 307  int    flags; Line 333  int    flags;
333                  }                  }
334          }          }
335          if (gtop->format & GTAGS_PATHINDEX || gtop->mode != GTAGS_READ) {          if (gtop->format & GTAGS_PATHINDEX || gtop->mode != GTAGS_READ) {
336                  if (gpath_open(dbpath, dbmode) < 0) {                  if (gpath_open(dbpath, dbmode, dbopflags) < 0) {
337                          if (dbmode == 1)                          if (dbmode == 1)
338                                  die("cannot create GPATH.");                                  die("cannot create GPATH.");
339                          else                          else
# Line 333  int    flags; Line 359  int    flags;
359   *      i)      gtop    descripter of GTOP   *      i)      gtop    descripter of GTOP
360   *      i)      tag     tag name   *      i)      tag     tag name
361   *      i)      record  ctags -x image   *      i)      record  ctags -x image
362     *      i)      fid     file id.
363   */   */
364  void  void
365  gtags_put(gtop, tag, record)  gtags_put(gtop, tag, record, fid)
366  GTOP    *gtop;  GTOP    *gtop;
367  char    *tag;  char    *tag;
368  char    *record;  char    *record;
369    char    *fid;
370  {  {
371          char    *p, *q;          char    *p, *q;
372          char    lno[10];          char    lno[32];
373          char    path[MAXPATHLEN+1];          char    path[MAXPATHLEN+1];
374    
375          if (gtop->format == GTAGS_STANDARD) {          if (gtop->format == GTAGS_STANDARD) {
376                  /* entab(record); */                  /* entab(record); */
377                  dbop_put(gtop->dbop, tag, record, 0);                  dbop_put(gtop->dbop, tag, record, fid);
378                  return;                  return;
379          }          }
380          /*          /*
# Line 371  char   *record; Line 399  char   *record;
399           * First time, it occurs, because 'prev_tag' and 'prev_path' are NULL.           * First time, it occurs, because 'prev_tag' and 'prev_path' are NULL.
400           */           */
401          if (strcmp(gtop->prev_tag, tag) || strcmp(gtop->prev_path, path)) {          if (strcmp(gtop->prev_tag, tag) || strcmp(gtop->prev_path, path)) {
402                  if (gtop->prev_tag[0])                  if (gtop->prev_tag[0]) {
403                          dbop_put(gtop->dbop, gtop->prev_tag, strbuf_value(gtop->sb), 0);                          dbop_put(gtop->dbop, gtop->prev_tag, strbuf_value(gtop->sb), gtop->prev_fid);
404                    }
405                  strcpy(gtop->prev_tag, tag);                  strcpy(gtop->prev_tag, tag);
406                  strcpy(gtop->prev_path, path);                  strcpy(gtop->prev_path, path);
407                    strcpy(gtop->prev_fid, fid);
408                  /*                  /*
409                   * Start creating new record.                   * Start creating new record.
410                   */                   */
# Line 410  int    flags; Line 440  int    flags;
440          STRBUF  *ib = strbuf_open(MAXBUFLEN);          STRBUF  *ib = strbuf_open(MAXBUFLEN);
441          char    sort_command[MAXFILLEN+1];          char    sort_command[MAXFILLEN+1];
442          char    sed_command[MAXFILLEN+1];          char    sed_command[MAXFILLEN+1];
443            char    *fid;
444    
445          /*          /*
446           * get command name of sort and sed.           * get command name of sort and sed.
# Line 439  int    flags; Line 470  int    flags;
470          strbuf_reset(sb);          strbuf_reset(sb);
471          makecommand(comline, path, sb);          makecommand(comline, path, sb);
472          /*          /*
473             * get file id.
474             */
475            if (gtop->format & GTAGS_PATHINDEX || gtop->openflags & GTAGS_POSTGRES) {
476                    if (!(fid = gpath_path2fid(path)))
477                            die("GPATH is corrupted.('%s' not found)", path);
478            } else
479                    fid = "0";
480            /*
481           * Compact format.           * Compact format.
482           */           */
483          if (gtop->format & GTAGS_PATHINDEX) {          if (gtop->format & GTAGS_PATHINDEX) {
                 char    *pno;  
   
                 if (!(pno = gpath_path2ids(path)))  
                         die("GPATH is corrupted.('%s' not found)", path);  
484                  strbuf_puts(sb, "| ");                  strbuf_puts(sb, "| ");
485                  strbuf_puts(sb, sed_command);                  strbuf_puts(sb, sed_command);
486                  strbuf_putc(sb, ' ');                  strbuf_putc(sb, ' ');
487                  strbuf_puts(sb, "\"s@");                  strbuf_puts(sb, "\"s@");
488                  strbuf_puts(sb, path);                  strbuf_puts(sb, path);
489                  strbuf_puts(sb, "@");                  strbuf_puts(sb, "@");
490                  strbuf_puts(sb, pno);                  strbuf_puts(sb, fid);
491                  strbuf_puts(sb, "@\"");                  strbuf_puts(sb, "@\"");
492          }          }
493          if (gtop->format & GTAGS_COMPACT) {          if (gtop->format & GTAGS_COMPACT) {
# Line 488  int    flags; Line 523  int    flags;
523                          else if ((p = locatestring(tag, "::", MATCH_LAST)) != NULL)                          else if ((p = locatestring(tag, "::", MATCH_LAST)) != NULL)
524                                  tag = p + 2;                                  tag = p + 2;
525                  }                  }
526                  gtags_put(gtop, tag, tagline);                  gtags_put(gtop, tag, tagline, fid);
527          }          }
528          pclose(ip);          pclose(ip);
529          strbuf_close(sb);          strbuf_close(sb);
# Line 541  gtags_delete(gtop, path) Line 576  gtags_delete(gtop, path)
576  GTOP    *gtop;  GTOP    *gtop;
577  char    *path;  char    *path;
578  {  {
579          char    *p, *key;          char *p, *fid;
   
580          /*          /*
581           * In compact format, a path is saved as a file number.           * In compact format, a path is saved as a file number.
582           */           */
         key = path;  
583          if (gtop->format & GTAGS_PATHINDEX)          if (gtop->format & GTAGS_PATHINDEX)
584                  if ((key = gpath_ids2path(path)) == NULL)                  if ((path = gpath_fid2path(path)) == NULL)
585                          die("GPATH is corrupted.('%s' not found)", path);                          die("GPATH is corrupted.('%s' not found)", path);
586    #ifdef USE_POSTGRES
587            if (gtop->openflags & GTAGS_POSTGRES) {
588                    char *fid;
589    
590                    if ((fid = gpath_path2fid(path)) == NULL)
591                            die("GPATH is corrupted.('%s' not found)", path);
592                    dbop_delete_by_fid(gtop->dbop, fid);
593                    return;
594            }
595    #endif
596          /*          /*
597           * read sequentially, because db(1) has just one index.           * read sequentially, because db(1) has just one index.
598           */           */
599          for (p = dbop_first(gtop->dbop, NULL, NULL, 0); p; p = dbop_next(gtop->dbop))          for (p = dbop_first(gtop->dbop, NULL, NULL, 0); p; p = dbop_next(gtop->dbop))
600                  if (belongto(gtop, key, p))                  if (belongto(gtop, path, p))
601                          dbop_delete(gtop->dbop, NULL);                          dbop_delete(gtop->dbop, NULL);
602          /*          /*
603           * don't delete from path index.           * don't delete from path index.
# Line 674  GTOP   *gtop; Line 717  GTOP   *gtop;
717          if (gtop->format & GTAGS_PATHINDEX || gtop->mode != GTAGS_READ)          if (gtop->format & GTAGS_PATHINDEX || gtop->mode != GTAGS_READ)
718                  gpath_close();                  gpath_close();
719          if (gtop->sb && gtop->prev_tag[0])          if (gtop->sb && gtop->prev_tag[0])
720                  dbop_put(gtop->dbop, gtop->prev_tag, strbuf_value(gtop->sb), 0);                  dbop_put(gtop->dbop, gtop->prev_tag, strbuf_value(gtop->sb), "0");
721          if (gtop->sb)          if (gtop->sb)
722                  strbuf_close(gtop->sb);                  strbuf_close(gtop->sb);
723          if (gtop->ib)          if (gtop->ib)
# Line 711  GTOP   *gtop; Line 754  GTOP   *gtop;
754                          while (!isspace(*p))                          while (!isspace(*p))
755                                  *q++ = *p++;                                  *q++ = *p++;
756                          *q = 0;                          *q = 0;
757                          if ((name = gpath_ids2path(path)) == NULL)                          if ((name = gpath_fid2path(path)) == NULL)
758                                  die("GPATH is corrupted.('%s' not found)", path);                                  die("GPATH is corrupted.('%s' not found)", path);
759                          strcpy(gtop->path, name);                          strcpy(gtop->path, name);
760                  } else {                  } else {

Legend:
Removed from v.1.14  
changed lines
  Added in v.1.15

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26