[BACK]Return to mandocdb.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mandocdb.c between version 1.4 and 1.5

version 1.4, 2011/07/15 10:15:24 version 1.5, 2011/07/15 17:59:29
Line 42 
Line 42 
 #define MANDOC_DB        "mandoc.db"  #define MANDOC_DB        "mandoc.db"
 #define MANDOC_IDX       "mandoc.index"  #define MANDOC_IDX       "mandoc.index"
 #define MANDOC_BUFSZ      BUFSIZ  #define MANDOC_BUFSZ      BUFSIZ
 #define MANDOC_FLAGS      O_CREAT|O_TRUNC|O_RDWR  
 #define MANDOC_SLOP       1024  #define MANDOC_SLOP       1024
   
 /* Bit-fields.  See mandocdb.8. */  /* Bit-fields.  See mandocdb.8. */
Line 61 
Line 60 
 #define TYPE_ENV          0x800  #define TYPE_ENV          0x800
 #define TYPE_ERR          0x1000  #define TYPE_ERR          0x1000
   
   /* Tiny list for files.  No need to bring in QUEUE. */
   
 struct  of {  struct  of {
         char             *fname;          char             *fname; /* heap-allocated */
         struct of        *next;          struct of        *next; /* NULL for last one */
         struct of        *first;          struct of        *first; /* first in list */
 };  };
   
 /* Buffer for storing growable data. */  /* Buffer for storing growable data. */
   
 struct  buf {  struct  buf {
         char             *cp;          char             *cp;
         size_t            len;          size_t            len; /* current length */
         size_t            size;          size_t            size; /* total buffer size */
 };  };
   
 /* Operation we're going to perform. */  /* Operation we're going to perform. */
   
 enum    op {  enum    op {
         OP_NEW = 0, /* new database */          OP_NEW = 0, /* new database */
         OP_UPDATE, /* update entries in existing database */          OP_UPDATE, /* delete/add entries in existing database */
         OP_DELETE /* delete entries from existing database */          OP_DELETE /* delete entries from existing database */
 };  };
   
Line 104  static void    hash_reset(DB **);
Line 105  static void    hash_reset(DB **);
 static  void              index_merge(const struct of *, struct mparse *,  static  void              index_merge(const struct of *, struct mparse *,
                                 struct buf *, struct buf *,                                  struct buf *, struct buf *,
                                 DB *, DB *, const char *,                                  DB *, DB *, const char *,
                                 DB *, const char *,                                  DB *, const char *, int,
                                 recno_t, const recno_t *, size_t);                                  recno_t, const recno_t *, size_t);
 static  void              index_prune(const struct of *, DB *,  static  void              index_prune(const struct of *, DB *,
                                 const char *, DB *, const char *,                                  const char *, DB *, const char *,
                                 recno_t *, recno_t **, size_t *);                                  int, recno_t *, recno_t **, size_t *);
 static  int               ofile_build(const char *, struct of **);  static  void              ofile_argbuild(char *[], int, int, struct of **);
   static  int               ofile_dirbuild(const char *, int, struct of **);
 static  void              ofile_free(struct of *);  static  void              ofile_free(struct of *);
 static  int               pman_node(MAN_ARGS);  static  int               pman_node(MAN_ARGS);
 static  void              pmdoc_node(MDOC_ARGS);  static  void              pmdoc_node(MDOC_ARGS);
Line 263  main(int argc, char *argv[])
Line 265  main(int argc, char *argv[])
 {  {
         struct mparse   *mp; /* parse sequence */          struct mparse   *mp; /* parse sequence */
         enum op          op; /* current operation */          enum op          op; /* current operation */
           const char      *dir;
         char             ibuf[MAXPATHLEN], /* index fname */          char             ibuf[MAXPATHLEN], /* index fname */
                          fbuf[MAXPATHLEN];  /* btree fname */                           fbuf[MAXPATHLEN];  /* btree fname */
         int              ch, i, flags;          int              verb, /* output verbosity */
                            ch, i, flags;
         DB              *idx, /* index database */          DB              *idx, /* index database */
                         *db, /* keyword database */                          *db, /* keyword database */
                         *hash; /* temporary keyword hashtable */                          *hash; /* temporary keyword hashtable */
         BTREEINFO        info; /* btree configuration */          BTREEINFO        info; /* btree configuration */
         recno_t          maxrec; /* supremum of all records */          recno_t          maxrec; /* supremum of all records */
         recno_t         *recs; /* buffer of empty records */          recno_t         *recs; /* buffer of empty records */
         size_t           recsz, /* buffer size of recs */          size_t           sz1, sz2,
                            recsz, /* buffer size of recs */
                          reccur; /* valid number of recs */                           reccur; /* valid number of recs */
         struct buf       buf, /* keyword buffer */          struct buf       buf, /* keyword buffer */
                          dbuf; /* description buffer */                           dbuf; /* description buffer */
         struct of       *of;          struct of       *of; /* list of files for processing */
         extern int       optind;          extern int       optind;
         extern char     *optarg;          extern char     *optarg;
   
Line 286  main(int argc, char *argv[])
Line 291  main(int argc, char *argv[])
         else          else
                 ++progname;                  ++progname;
   
           verb = 0;
         of = NULL;          of = NULL;
         db = idx = NULL;          db = idx = NULL;
         mp = NULL;          mp = NULL;
Line 294  main(int argc, char *argv[])
Line 300  main(int argc, char *argv[])
         recsz = reccur = 0;          recsz = reccur = 0;
         maxrec = 0;          maxrec = 0;
         op = OP_NEW;          op = OP_NEW;
           dir = NULL;
   
         memset(&buf, 0, sizeof(struct buf));          while (-1 != (ch = getopt(argc, argv, "d:u:v")))
         memset(&dbuf, 0, sizeof(struct buf));  
   
         while (-1 != (ch = getopt(argc, argv, "")))  
                 switch (ch) {                  switch (ch) {
                   case ('d'):
                           dir = optarg;
                           op = OP_UPDATE;
                           break;
                   case ('u'):
                           dir = optarg;
                           op = OP_DELETE;
                           break;
                   case ('v'):
                           verb++;
                           break;
                 default:                  default:
                         usage();                          usage();
                         return((int)MANDOCLEVEL_BADARG);                          return((int)MANDOCLEVEL_BADARG);
Line 313  main(int argc, char *argv[])
Line 328  main(int argc, char *argv[])
   
         mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);          mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);
   
         flags = OP_NEW == op ? O_CREAT|O_TRUNC|O_RDWR : O_CREAT|O_RDWR;          memset(&buf, 0, sizeof(struct buf));
           memset(&dbuf, 0, sizeof(struct buf));
   
         buf.size = dbuf.size = MANDOC_BUFSZ;          buf.size = dbuf.size = MANDOC_BUFSZ;
   
         buf.cp = mandoc_malloc(buf.size);          buf.cp = mandoc_malloc(buf.size);
         dbuf.cp = mandoc_malloc(dbuf.size);          dbuf.cp = mandoc_malloc(dbuf.size);
   
           flags = OP_NEW == op ? O_CREAT|O_TRUNC|O_RDWR : O_CREAT|O_RDWR;
   
           if (OP_UPDATE == op || OP_DELETE == op) {
                   ibuf[0] = fbuf[0] = '\0';
   
                   strlcat(fbuf, dir, MAXPATHLEN);
                   strlcat(fbuf, "/", MAXPATHLEN);
                   sz1 = strlcat(fbuf, MANDOC_DB, MAXPATHLEN);
   
                   strlcat(ibuf, dir, MAXPATHLEN);
                   strlcat(ibuf, "/", MAXPATHLEN);
                   sz2 = strlcat(ibuf, MANDOC_IDX, MAXPATHLEN);
   
                   if (sz1 >= MAXPATHLEN || sz2 >= MAXPATHLEN) {
                           fprintf(stderr, "%s: Path too long\n", dir);
                           exit((int)MANDOCLEVEL_BADARG);
                   }
   
                   db = dbopen(fbuf, flags, 0644, DB_BTREE, &info);
                   idx = dbopen(ibuf, flags, 0644, DB_RECNO, NULL);
   
                   if (NULL == db) {
                           perror(fbuf);
                           exit((int)MANDOCLEVEL_SYSERR);
                   } else if (NULL == db) {
                           perror(ibuf);
                           exit((int)MANDOCLEVEL_SYSERR);
                   }
   
                   if (verb > 2) {
                           printf("%s: Opened\n", fbuf);
                           printf("%s: Opened\n", ibuf);
                   }
   
                   ofile_argbuild(argv, argc, verb, &of);
                   if (NULL == of)
                           goto out;
   
                   of = of->first;
   
                   index_prune(of, db, fbuf, idx, ibuf, verb,
                                   &maxrec, &recs, &recsz);
   
                   if (OP_UPDATE == op)
                           index_merge(of, mp, &dbuf, &buf, hash,
                                           db, fbuf, idx, ibuf, verb,
                                           maxrec, recs, reccur);
   
                   goto out;
           }
   
         for (i = 0; i < argc; i++) {          for (i = 0; i < argc; i++) {
                 ibuf[0] = ibuf[MAXPATHLEN - 2] =                  ibuf[0] = fbuf[0] = '\0';
                         fbuf[0] = fbuf[MAXPATHLEN - 2] = '\0';  
   
                 strlcat(fbuf, argv[i], MAXPATHLEN);                  strlcat(fbuf, argv[i], MAXPATHLEN);
                 strlcat(fbuf, MANDOC_DB, MAXPATHLEN);                  strlcat(fbuf, "/", MAXPATHLEN);
                   sz1 = strlcat(fbuf, MANDOC_DB, MAXPATHLEN);
   
                 strlcat(ibuf, argv[i], MAXPATHLEN);                  strlcat(ibuf, argv[i], MAXPATHLEN);
                 strlcat(ibuf, MANDOC_IDX, MAXPATHLEN);                  strlcat(ibuf, "/", MAXPATHLEN);
                   sz2 = strlcat(ibuf, MANDOC_IDX, MAXPATHLEN);
   
                 if ('\0' != fbuf[MAXPATHLEN - 2] ||                  if (sz1 >= MAXPATHLEN || sz2 >= MAXPATHLEN) {
                                 '\0' != ibuf[MAXPATHLEN - 2]) {  
                         fprintf(stderr, "%s: Path too long\n", argv[i]);                          fprintf(stderr, "%s: Path too long\n", argv[i]);
                         break;                          exit((int)MANDOCLEVEL_BADARG);
                 }                  }
   
                 db = dbopen(fbuf, flags, 0644, DB_BTREE, &info);                  db = dbopen(fbuf, flags, 0644, DB_BTREE, &info);
Line 341  main(int argc, char *argv[])
Line 408  main(int argc, char *argv[])
   
                 if (NULL == db) {                  if (NULL == db) {
                         perror(fbuf);                          perror(fbuf);
                         break;                          exit((int)MANDOCLEVEL_SYSERR);
                 } else if (NULL == db) {                  } else if (NULL == db) {
                         perror(ibuf);                          perror(ibuf);
                         break;                          exit((int)MANDOCLEVEL_SYSERR);
                 }                  }
   
                   if (verb > 2) {
                           printf("%s: Truncated\n", fbuf);
                           printf("%s: Truncated\n", ibuf);
                   }
   
                 ofile_free(of);                  ofile_free(of);
                 of = NULL;                  of = NULL;
   
                 if ( ! ofile_build(argv[i], &of))                  if ( ! ofile_dirbuild(argv[i], verb, &of))
                         break;                          exit((int)MANDOCLEVEL_SYSERR);
                 of = of->first;  
   
                 if (OP_DELETE == op || OP_UPDATE == op)                  if (NULL == of)
                         index_prune(of, db, fbuf, idx, ibuf,  
                                         &maxrec, &recs, &recsz);  
   
                 if (OP_DELETE == op)  
                         continue;                          continue;
   
                 index_merge(of, mp, &dbuf, &buf, hash, db,                  of = of->first;
                                 fbuf, idx, ibuf, maxrec, recs, reccur);  
                   index_merge(of, mp, &dbuf, &buf, hash, db, fbuf,
                                   idx, ibuf, verb, maxrec, recs, reccur);
         }          }
   
   out:
         if (db)          if (db)
                 (*db->close)(db);                  (*db->close)(db);
         if (idx)          if (idx)
Line 379  main(int argc, char *argv[])
Line 449  main(int argc, char *argv[])
         free(dbuf.cp);          free(dbuf.cp);
         free(recs);          free(recs);
   
         return(i < argc ? MANDOCLEVEL_SYSERR : MANDOCLEVEL_OK);          return(MANDOCLEVEL_OK);
 }  }
   
 void  void
 index_merge(const struct of *of, struct mparse *mp,  index_merge(const struct of *of, struct mparse *mp,
                 struct buf *dbuf, struct buf *buf,                  struct buf *dbuf, struct buf *buf,
                 DB *hash, DB *db, const char *dbf,                  DB *hash, DB *db, const char *dbf,
                 DB *idx, const char *idxf,                  DB *idx, const char *idxf, int verb,
                 recno_t maxrec, const recno_t *recs, size_t reccur)                  recno_t maxrec, const recno_t *recs, size_t reccur)
 {  {
         recno_t          rec;          recno_t          rec;
Line 472  index_merge(const struct of *of, struct mparse *mp,
Line 542  index_merge(const struct of *of, struct mparse *mp,
                         val.size = sizeof(vbuf);                          val.size = sizeof(vbuf);
                         val.data = vbuf;                          val.data = vbuf;
   
                         printf("%s: Added keyword: %s\n",                          if (verb > 1)
                                         fn, (char *)key.data);                                  printf("%s: Added keyword: %s\n",
                                                   fn, (char *)key.data);
                         dbt_put(db, dbf, &key, &val);                          dbt_put(db, dbf, &key, &val);
                 }                  }
                 if (ch < 0) {                  if (ch < 0) {
Line 495  index_merge(const struct of *of, struct mparse *mp,
Line 566  index_merge(const struct of *of, struct mparse *mp,
                 val.data = dbuf->cp;                  val.data = dbuf->cp;
                 val.size = dbuf->len;                  val.size = dbuf->len;
   
                 printf("%s: Added index\n", fn);                  if (verb)
                           printf("%s: Added index\n", fn);
                 dbt_put(idx, idxf, &key, &val);                  dbt_put(idx, idxf, &key, &val);
         }          }
 }  }
Line 508  index_merge(const struct of *of, struct mparse *mp,
Line 580  index_merge(const struct of *of, struct mparse *mp,
  */   */
 static void  static void
 index_prune(const struct of *ofile, DB *db, const char *dbf,  index_prune(const struct of *ofile, DB *db, const char *dbf,
                 DB *idx, const char *idxf,                  DB *idx, const char *idxf, int verb,
                 recno_t *maxrec, recno_t **recs, size_t *recsz)                  recno_t *maxrec, recno_t **recs, size_t *recsz)
 {  {
         const struct of *of;          const struct of *of;
Line 548  index_prune(const struct of *ofile, DB *db, const char
Line 620  index_prune(const struct of *ofile, DB *db, const char
                         assert(8 == val.size);                          assert(8 == val.size);
                         if (*maxrec != *(recno_t *)(val.data + 4))                          if (*maxrec != *(recno_t *)(val.data + 4))
                                 continue;                                  continue;
                         printf("%s: Deleted keyword: %s\n",                          if (verb)
                                 fn, (char *)key.data);                                  printf("%s: Deleted keyword: %s\n",
                                                   fn, (char *)key.data);
                         ch = (*db->del)(db, &key, R_CURSOR);                          ch = (*db->del)(db, &key, R_CURSOR);
                         if (ch < 0)                          if (ch < 0)
                                 break;                                  break;
Line 559  index_prune(const struct of *ofile, DB *db, const char
Line 632  index_prune(const struct of *ofile, DB *db, const char
                         exit((int)MANDOCLEVEL_SYSERR);                          exit((int)MANDOCLEVEL_SYSERR);
                 }                  }
   
                 printf("%s: Deleted index\n", fn);                  if (verb)
                           printf("%s: Deleted index\n", fn);
   
                 val.size = 0;                  val.size = 0;
                 ch = (*idx->put)(idx, &key, &val, R_CURSOR);                  ch = (*idx->put)(idx, &key, &val, R_CURSOR);
Line 665  hash_reset(DB **db)
Line 739  hash_reset(DB **db)
         if (NULL != (hash = *db))          if (NULL != (hash = *db))
                 (*hash->close)(hash);                  (*hash->close)(hash);
   
         *db = dbopen(NULL, MANDOC_FLAGS, 0644, DB_HASH, NULL);          *db = dbopen(NULL, O_CREAT|O_RDWR, 0644, DB_HASH, NULL);
         if (NULL == *db) {          if (NULL == *db) {
                 perror("hash");                  perror("hash");
                 exit((int)MANDOCLEVEL_SYSERR);                  exit((int)MANDOCLEVEL_SYSERR);
Line 1102  pman_node(MAN_ARGS)
Line 1176  pman_node(MAN_ARGS)
         return(0);          return(0);
 }  }
   
   static void
   ofile_argbuild(char *argv[], int argc, int verb, struct of **of)
   {
           int              i;
           struct of       *nof;
   
           for (i = 0; i < argc; i++) {
                   nof = mandoc_calloc(1, sizeof(struct of));
                   nof->fname = strdup(argv[i]);
                   if (verb > 2)
                           printf("%s: Scheduling\n", argv[i]);
                   if (NULL == *of) {
                           *of = nof;
                           (*of)->first = nof;
                   } else {
                           nof->first = (*of)->first;
                           (*of)->next = nof;
                           *of = nof;
                   }
           }
   }
   
 /*  /*
  * Recursively build up a list of files to parse.   * Recursively build up a list of files to parse.
  * We use this instead of ftw() and so on because I don't want global   * We use this instead of ftw() and so on because I don't want global
Line 1111  pman_node(MAN_ARGS)
Line 1207  pman_node(MAN_ARGS)
  * Pass in a pointer to a NULL structure for the first invocation.   * Pass in a pointer to a NULL structure for the first invocation.
  */   */
 static int  static int
 ofile_build(const char *dir, struct of **of)  ofile_dirbuild(const char *dir, int verb, struct of **of)
 {  {
           char             buf[MAXPATHLEN];
           size_t           sz;
         DIR             *d;          DIR             *d;
         const char      *fn;          const char      *fn;
         struct of       *nof;          struct of       *nof;
Line 1126  ofile_build(const char *dir, struct of **of)
Line 1224  ofile_build(const char *dir, struct of **of)
         while (NULL != (dp = readdir(d))) {          while (NULL != (dp = readdir(d))) {
                 fn = dp->d_name;                  fn = dp->d_name;
                 if (DT_DIR == dp->d_type) {                  if (DT_DIR == dp->d_type) {
                         if (strcmp(".", fn) && strcmp("..", fn))                          if (0 == strcmp(".", fn))
                                 if ( ! ofile_build(dp->d_name, of))                                  continue;
                           if (0 == strcmp("..", fn))
                                   continue;
   
                           buf[0] = '\0';
                           strlcat(buf, dir, MAXPATHLEN);
                           strlcat(buf, "/", MAXPATHLEN);
                           sz = strlcat(buf, fn, MAXPATHLEN);
   
                           if (sz < MAXPATHLEN) {
                                   if ( ! ofile_dirbuild(buf, verb, of))
                                         return(0);                                          return(0);
                                   continue;
                           } else if (sz < MAXPATHLEN)
                                   continue;
   
                           fprintf(stderr, "%s: Path too long\n", dir);
                           return(0);
                   }
                   if (DT_REG != dp->d_type)
                         continue;                          continue;
                 } else if (DT_REG != dp->d_type)  
                         continue;  
   
                 if (0 == strcmp(MANDOC_DB, fn) ||                  if (0 == strcmp(MANDOC_DB, fn) ||
                                 0 == strcmp(MANDOC_IDX, fn))                                  0 == strcmp(MANDOC_IDX, fn))
                         continue;                          continue;
   
                   buf[0] = '\0';
                   strlcat(buf, dir, MAXPATHLEN);
                   strlcat(buf, "/", MAXPATHLEN);
                   strlcat(buf, fn, MAXPATHLEN);
                   if (sz >= MAXPATHLEN) {
                           fprintf(stderr, "%s: Path too long\n", dir);
                           return(0);
                   }
   
                 nof = mandoc_calloc(1, sizeof(struct of));                  nof = mandoc_calloc(1, sizeof(struct of));
                 nof->fname = mandoc_strdup(fn);                  nof->fname = mandoc_strdup(buf);
   
                   if (verb > 2)
                           printf("%s: Scheduling\n", buf);
   
                 if (NULL == *of) {                  if (NULL == *of) {
                         *of = nof;                          *of = nof;
                         (*of)->first = nof;                          (*of)->first = nof;
                 } else {                  } else {
                           nof->first = (*of)->first;
                         (*of)->next = nof;                          (*of)->next = nof;
                         *of = nof;                          *of = nof;
                 }                  }
Line 1169  static void
Line 1296  static void
 usage(void)  usage(void)
 {  {
   
         fprintf(stderr, "usage: %s [dir...]\n", progname);          fprintf(stderr, "usage: %s [-v] "
                           "[-d dir [files...] |"
                           " -u dir [files...] |"
                           " dir...]\n", progname);
 }  }

Legend:
Removed from v.1.4  
changed lines
  Added in v.1.5

CVSweb