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

Diff for /mandoc/mandocdb.c between version 1.2 and 1.9

version 1.2, 2011/07/14 14:36:37 version 1.9, 2011/11/20 12:39:08
Line 21 
Line 21 
 #include <sys/param.h>  #include <sys/param.h>
   
 #include <assert.h>  #include <assert.h>
   #include <dirent.h>
 #include <fcntl.h>  #include <fcntl.h>
 #include <getopt.h>  #include <getopt.h>
 #include <stdio.h>  #include <stdio.h>
Line 37 
Line 38 
 #include "man.h"  #include "man.h"
 #include "mdoc.h"  #include "mdoc.h"
 #include "mandoc.h"  #include "mandoc.h"
   #include "mandocdb.h"
   
 #define MANDOC_DB        "mandoc.db"  
 #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. */  /* Tiny list for files.  No need to bring in QUEUE. */
   
 #define TYPE_NAME         0x01  struct  of {
 #define TYPE_FUNCTION     0x02          char             *fname; /* heap-allocated */
 #define TYPE_UTILITY      0x04          struct of        *next; /* NULL for last one */
 #define TYPE_INCLUDES     0x08          struct of        *first; /* first in list */
 #define TYPE_VARIABLE     0x10  };
 #define TYPE_STANDARD     0x20  
 #define TYPE_AUTHOR       0x40  
 #define TYPE_CONFIG       0x80  
 #define TYPE_DESC         0x100  
 #define TYPE_XREF         0x200  
 #define TYPE_PATH         0x400  
 #define TYPE_ENV          0x800  
 #define TYPE_ERR          0x1000  
   
 /* 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 92  static void    buf_append(struct buf *, const char *);
Line 83  static void    buf_append(struct buf *, const char *);
 static  void              buf_appendb(struct buf *,  static  void              buf_appendb(struct buf *,
                                 const void *, size_t);                                  const void *, size_t);
 static  void              dbt_put(DB *, const char *, DBT *, DBT *);  static  void              dbt_put(DB *, const char *, DBT *, DBT *);
 static  void              hash_put(DB *, const struct buf *, int);  static  void              hash_put(DB *, const struct buf *, uint64_t);
 static  void              hash_reset(DB **);  static  void              hash_reset(DB **);
   static  void              index_merge(const struct of *, struct mparse *,
                                   struct buf *, struct buf *,
                                   DB *, DB *, const char *,
                                   DB *, const char *, int,
                                   recno_t, const recno_t *, size_t);
   static  void              index_prune(const struct of *, DB *,
                                   const char *, DB *, const char *,
                                   int, recno_t *, recno_t **, size_t *);
   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  int               pman_node(MAN_ARGS);  static  int               pman_node(MAN_ARGS);
 static  void              pmdoc_node(MDOC_ARGS);  static  void              pmdoc_node(MDOC_ARGS);
 static  void              pmdoc_An(MDOC_ARGS);  static  void              pmdoc_An(MDOC_ARGS);
Line 245  int
Line 247  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
         struct mparse   *mp; /* parse sequence */          struct mparse   *mp; /* parse sequence */
         struct mdoc     *mdoc; /* resulting mdoc */  
         struct man      *man; /* resulting man */  
         enum op          op; /* current operation */          enum op          op; /* current operation */
         char            *fn; /* current file being parsed */          const char      *dir;
         const char      *msec, /* manual section */  
                         *mtitle, /* manual title */  
                         *arch, /* manual architecture */  
                         *dir; /* result dir (default: cwd) */  
         char             ibuf[MAXPATHLEN], /* index fname */          char             ibuf[MAXPATHLEN], /* index fname */
                          fbuf[MAXPATHLEN],  /* btree fname */                           fbuf[MAXPATHLEN];  /* btree fname */
                          vbuf[8]; /* stringified record number */          int              verb, /* output verbosity */
         int              ch, seq, sseq, verb, i;                           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 */
         DBT              key, val;  
         enum mandoclevel ec; /* exit status */  
         size_t           sv;  
         BTREEINFO        info; /* btree configuration */          BTREEINFO        info; /* btree configuration */
         recno_t          rec,          recno_t          maxrec; /* supremum of all records */
                          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; /* list of files for processing */
         extern int       optind;          extern int       optind;
         extern char     *optarg;          extern char     *optarg;
   
Line 280  main(int argc, char *argv[])
Line 274  main(int argc, char *argv[])
         else          else
                 ++progname;                  ++progname;
   
         dir = "";  
         verb = 0;          verb = 0;
           of = NULL;
         db = idx = NULL;          db = idx = NULL;
         mp = NULL;          mp = NULL;
         hash = NULL;          hash = NULL;
Line 289  main(int argc, char *argv[])
Line 283  main(int argc, char *argv[])
         recsz = reccur = 0;          recsz = reccur = 0;
         maxrec = 0;          maxrec = 0;
         op = OP_NEW;          op = OP_NEW;
         ec = MANDOCLEVEL_SYSERR;          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, "d:ruv")))  
                 switch (ch) {                  switch (ch) {
                 case ('d'):                  case ('d'):
                         dir = optarg;                          dir = optarg;
                           op = OP_UPDATE;
                         break;                          break;
                 case ('r'):                  case ('u'):
                           dir = optarg;
                         op = OP_DELETE;                          op = OP_DELETE;
                         break;                          break;
                 case ('u'):  
                         op = OP_UPDATE;  
                         break;  
                 case ('v'):                  case ('v'):
                         verb++;                          verb++;
                         break;                          break;
Line 316  main(int argc, char *argv[])
Line 306  main(int argc, char *argv[])
         argc -= optind;          argc -= optind;
         argv += optind;          argv += optind;
   
         ibuf[0] = ibuf[MAXPATHLEN - 2] =          memset(&info, 0, sizeof(BTREEINFO));
                 fbuf[0] = fbuf[MAXPATHLEN - 2] = '\0';          info.flags = R_DUP;
   
         strlcat(fbuf, dir, MAXPATHLEN);          mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);
         strlcat(fbuf, MANDOC_DB, MAXPATHLEN);  
   
         strlcat(ibuf, dir, MAXPATHLEN);          memset(&buf, 0, sizeof(struct buf));
         strlcat(ibuf, MANDOC_IDX, MAXPATHLEN);          memset(&dbuf, 0, sizeof(struct buf));
   
         if ('\0' != fbuf[MAXPATHLEN - 2] ||          buf.size = dbuf.size = MANDOC_BUFSZ;
                         '\0' != ibuf[MAXPATHLEN - 2]) {  
                 fprintf(stderr, "%s: Path too long\n", dir);  
                 goto out;  
         }  
   
         /*          buf.cp = mandoc_malloc(buf.size);
          * For the keyword database, open a BTREE database that allows          dbuf.cp = mandoc_malloc(dbuf.size);
          * duplicates.  
          * For the index database, use a standard RECNO database type.  
          * Truncate the database if we're creating a new one.  
          */  
   
         memset(&info, 0, sizeof(BTREEINFO));          flags = OP_NEW == op ? O_CREAT|O_TRUNC|O_RDWR : O_CREAT|O_RDWR;
         info.flags = R_DUP;  
   
         if (OP_NEW == op) {          if (OP_UPDATE == op || OP_DELETE == op) {
                 db = dbopen(fbuf, MANDOC_FLAGS, 0644, DB_BTREE, &info);                  ibuf[0] = fbuf[0] = '\0';
                 idx = dbopen(ibuf, MANDOC_FLAGS, 0644, DB_RECNO, NULL);  
         } else {  
                 db = dbopen(fbuf, O_CREAT|O_RDWR, 0644, DB_BTREE, &info);  
                 idx = dbopen(ibuf, O_CREAT|O_RDWR, 0644, DB_RECNO, NULL);  
         }  
   
         if (NULL == db) {                  strlcat(fbuf, dir, MAXPATHLEN);
                 perror(fbuf);                  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;                  goto out;
         } else if (NULL == db) {  
                 perror(ibuf);  
                 goto out;  
         }          }
   
         /*          for (i = 0; i < argc; i++) {
          * If we're going to delete or update a database, remove the                  ibuf[0] = fbuf[0] = '\0';
          * entries now (both the index and all keywords pointing to it).  
          * This doesn't actually remove them: it only sets their record  
          * value lengths to zero.  
          * While doing so, add the empty records to a list we'll access  
          * later in re-adding entries to the database.  
          */  
   
         if (OP_DELETE == op || OP_UPDATE == op) {                  strlcat(fbuf, argv[i], MAXPATHLEN);
                 seq = R_FIRST;                  strlcat(fbuf, "/", MAXPATHLEN);
                 while (0 == (ch = (*idx->seq)(idx, &key, &val, seq))) {                  sz1 = strlcat(fbuf, MANDOC_DB, MAXPATHLEN);
                         seq = R_NEXT;  
                         maxrec = *(recno_t *)key.data;  
                         if (0 == val.size && OP_UPDATE == op) {  
                                 if (reccur >= recsz) {  
                                         recsz += MANDOC_SLOP;  
                                         recs = mandoc_realloc  
                                                 (recs, recsz * sizeof(recno_t));  
                                 }  
                                 recs[(int)reccur] = maxrec;  
                                 reccur++;  
                                 continue;  
                         }  
   
                         fn = (char *)val.data;                  strlcat(ibuf, argv[i], MAXPATHLEN);
                         for (i = 0; i < argc; i++)                  strlcat(ibuf, "/", MAXPATHLEN);
                                 if (0 == strcmp(fn, argv[i]))                  sz2 = strlcat(ibuf, MANDOC_IDX, MAXPATHLEN);
                                         break;  
   
                         if (i == argc)                  if (sz1 >= MAXPATHLEN || sz2 >= MAXPATHLEN) {
                                 continue;                          fprintf(stderr, "%s: Path too long\n", argv[i]);
                           exit((int)MANDOCLEVEL_BADARG);
                   }
   
                         sseq = R_FIRST;                  db = dbopen(fbuf, flags, 0644, DB_BTREE, &info);
                         while (0 == (ch = (*db->seq)(db, &key, &val, sseq))) {                  idx = dbopen(ibuf, flags, 0644, DB_RECNO, NULL);
                                 sseq = R_NEXT;  
                                 assert(8 == val.size);  
                                 if (maxrec != *(recno_t *)(val.data + 4))  
                                         continue;  
                                 if (verb > 1)  
                                         printf("%s: Deleted keyword: %s\n",  
                                                 fn, (char *)key.data);  
                                 ch = (*db->del)(db, &key, R_CURSOR);  
                                 if (ch < 0)  
                                         break;  
                         }  
                         if (ch < 0) {  
                                 perror(fbuf);  
                                 exit((int)MANDOCLEVEL_SYSERR);  
                         }  
   
                         if (verb)                  if (NULL == db) {
                                 printf("%s: Deleted index\n", fn);                          perror(fbuf);
                           exit((int)MANDOCLEVEL_SYSERR);
                   } else if (NULL == db) {
                           perror(ibuf);
                           exit((int)MANDOCLEVEL_SYSERR);
                   }
   
                         val.size = 0;                  if (verb > 2) {
                         ch = (*idx->put)(idx, &key, &val, R_CURSOR);                          printf("%s: Truncated\n", fbuf);
                         if (ch < 0) {                          printf("%s: Truncated\n", ibuf);
                                 perror(ibuf);  
                                 exit((int)MANDOCLEVEL_SYSERR);  
                         }  
   
                         if (OP_UPDATE == op) {  
                                 if (reccur >= recsz) {  
                                         recsz += MANDOC_SLOP;  
                                         recs = mandoc_realloc  
                                                 (recs, recsz * sizeof(recno_t));  
                                 }  
                                 recs[(int)reccur] = maxrec;  
                                 reccur++;  
                         }  
                 }                  }
                 maxrec++;  
         }  
   
         if (OP_DELETE == op) {                  ofile_free(of);
                 ec = MANDOCLEVEL_OK;                  of = NULL;
                 goto out;  
                   if ( ! ofile_dirbuild(argv[i], verb, &of))
                           exit((int)MANDOCLEVEL_SYSERR);
   
                   if (NULL == of)
                           continue;
   
                   of = of->first;
   
                   index_merge(of, mp, &dbuf, &buf, hash, db, fbuf,
                                   idx, ibuf, verb, maxrec, recs, reccur);
         }          }
   
         /*  out:
          * Add records to the database.          if (db)
          * Try parsing each manual given on the command line.                  (*db->close)(db);
          * If we fail, then emit an error and keep on going.          if (idx)
          * Take resulting trees and push them down into the database code.                  (*idx->close)(idx);
          * Use the auto-parser and don't report any errors.          if (hash)
          */                  (*hash->close)(hash);
           if (mp)
                   mparse_free(mp);
   
         mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);          ofile_free(of);
           free(buf.cp);
           free(dbuf.cp);
           free(recs);
   
         buf.size = dbuf.size = MANDOC_BUFSZ;          return(MANDOCLEVEL_OK);
         buf.cp = mandoc_malloc(buf.size);  }
         dbuf.cp = mandoc_malloc(dbuf.size);  
   
         for (rec = 0, i = 0; i < argc; i++) {  void
                 fn = argv[i];  index_merge(const struct of *of, struct mparse *mp,
                 if (OP_UPDATE == op) {                  struct buf *dbuf, struct buf *buf,
                         if (reccur > 0) {                  DB *hash, DB *db, const char *dbf,
                                 --reccur;                  DB *idx, const char *idxf, int verb,
                                 rec = recs[(int)reccur];                  recno_t maxrec, const recno_t *recs, size_t reccur)
                         } else if (maxrec > 0) {  {
                                 rec = maxrec;          recno_t          rec;
                                 maxrec = 0;          int              ch;
                         } else          DBT              key, val;
                                 rec++;          struct mdoc     *mdoc;
           struct man      *man;
           const char      *fn, *msec, *mtitle, *arch;
           size_t           sv;
           unsigned         seq;
           struct db_val    vbuf;
   
           for (rec = 0; of; of = of->next) {
                   fn = of->fname;
                   if (reccur > 0) {
                           --reccur;
                           rec = recs[(int)reccur];
                   } else if (maxrec > 0) {
                           rec = maxrec;
                           maxrec = 0;
                 } else                  } else
                         rec++;                          rec++;
   
Line 480  main(int argc, char *argv[])
Line 479  main(int argc, char *argv[])
                         mdoc_meta(mdoc)->msec : man_meta(man)->msec;                          mdoc_meta(mdoc)->msec : man_meta(man)->msec;
                 mtitle = NULL != mdoc ?                  mtitle = NULL != mdoc ?
                         mdoc_meta(mdoc)->title : man_meta(man)->title;                          mdoc_meta(mdoc)->title : man_meta(man)->title;
                 arch = NULL != mdoc ? mdoc_meta(mdoc)->arch : NULL;                  arch = NULL != mdoc ?
                           mdoc_meta(mdoc)->arch : NULL;
   
                 if (NULL == arch)                  if (NULL == arch)
                         arch = "";                          arch = "";
Line 493  main(int argc, char *argv[])
Line 493  main(int argc, char *argv[])
                  * going to write a nil byte in its place.                   * going to write a nil byte in its place.
                  */                   */
   
                 dbuf.len = 0;                  dbuf->len = 0;
                 buf_appendb(&dbuf, fn, strlen(fn) + 1);                  buf_appendb(dbuf, fn, strlen(fn) + 1);
                 buf_appendb(&dbuf, msec, strlen(msec) + 1);                  buf_appendb(dbuf, msec, strlen(msec) + 1);
                 buf_appendb(&dbuf, mtitle, strlen(mtitle) + 1);                  buf_appendb(dbuf, mtitle, strlen(mtitle) + 1);
                 buf_appendb(&dbuf, arch, strlen(arch) + 1);                  buf_appendb(dbuf, arch, strlen(arch) + 1);
   
                 sv = dbuf.len;                  sv = dbuf->len;
   
                 /* Fix the record number in the btree value. */                  /* Fix the record number in the btree value. */
   
                 if (mdoc)                  if (mdoc)
                         pmdoc_node(hash, &buf, &dbuf,                          pmdoc_node(hash, buf, dbuf,
                                 mdoc_node(mdoc), mdoc_meta(mdoc));                                  mdoc_node(mdoc), mdoc_meta(mdoc));
                 else                  else
                         pman_node(hash, &buf, &dbuf, man_node(man));                          pman_node(hash, buf, dbuf, man_node(man));
   
                 /*                  /*
                  * Copy from the in-memory hashtable of pending keywords                   * Copy from the in-memory hashtable of pending keywords
                  * into the database.                   * into the database.
                  */                   */
   
                 memset(vbuf, 0, sizeof(uint32_t));  
                 memcpy(vbuf + 4, &rec, sizeof(uint32_t));  
   
                   vbuf.rec = rec;
                 seq = R_FIRST;                  seq = R_FIRST;
                 while (0 == (ch = (*hash->seq)(hash, &key, &val, seq))) {                  while (0 == (ch = (*hash->seq)(hash, &key, &val, seq))) {
                         seq = R_NEXT;                          seq = R_NEXT;
   
                         memcpy(vbuf, val.data, sizeof(uint32_t));                          vbuf.mask = *(uint64_t *)val.data;
                         val.size = sizeof(vbuf);                          val.size = sizeof(struct db_val);
                         val.data = vbuf;                          val.data = &vbuf;
   
                         if (verb > 1)                          if (verb > 1)
                                 printf("%s: Added keyword: %s, 0x%x\n",                                  printf("%s: Added keyword: %s\n",
                                         fn, (char *)key.data,                                                  fn, (char *)key.data);
                                         *(int *)val.data);                          dbt_put(db, dbf, &key, &val);
                         dbt_put(db, fbuf, &key, &val);  
                 }                  }
                 if (ch < 0) {                  if (ch < 0) {
                         perror("hash");                          perror("hash");
Line 541  main(int argc, char *argv[])
Line 538  main(int argc, char *argv[])
                  * set, put an empty one in now.                   * set, put an empty one in now.
                  */                   */
   
                 if (dbuf.len == sv)                  if (dbuf->len == sv)
                         buf_appendb(&dbuf, "", 1);                          buf_appendb(dbuf, "", 1);
   
                 key.data = &rec;                  key.data = &rec;
                 key.size = sizeof(recno_t);                  key.size = sizeof(recno_t);
   
                 val.data = dbuf.cp;                  val.data = dbuf->cp;
                 val.size = dbuf.len;                  val.size = dbuf->len;
   
                 if (verb > 0)                  if (verb)
                         printf("%s: Added index\n", fn);                          printf("%s: Added index\n", fn);
                   dbt_put(idx, idxf, &key, &val);
                 dbt_put(idx, ibuf, &key, &val);  
         }          }
   }
   
         ec = MANDOCLEVEL_OK;  /*
 out:   * Scan through all entries in the index file `idx' and prune those
         if (db)   * entries in `ofile'.
                 (*db->close)(db);   * Pruning consists of removing from `db', then invalidating the entry
         if (idx)   * in `idx' (zeroing its value size).
                 (*idx->close)(idx);   */
         if (hash)  static void
                 (*hash->close)(hash);  index_prune(const struct of *ofile, DB *db, const char *dbf,
         if (mp)                  DB *idx, const char *idxf, int verb,
                 mparse_free(mp);                  recno_t *maxrec, recno_t **recs, size_t *recsz)
   {
           const struct of *of;
           const char      *fn;
           struct db_val   *vbuf;
           unsigned         seq, sseq;
           DBT              key, val;
           size_t           reccur;
           int              ch;
   
         free(buf.cp);          reccur = 0;
         free(dbuf.cp);          seq = R_FIRST;
         free(recs);          while (0 == (ch = (*idx->seq)(idx, &key, &val, seq))) {
                   seq = R_NEXT;
                   *maxrec = *(recno_t *)key.data;
                   if (0 == val.size) {
                           if (reccur >= *recsz) {
                                   *recsz += MANDOC_SLOP;
                                   *recs = mandoc_realloc(*recs,
                                           *recsz * sizeof(recno_t));
                           }
                           (*recs)[(int)reccur] = *maxrec;
                           reccur++;
                           continue;
                   }
   
         return((int)ec);                  fn = (char *)val.data;
                   for (of = ofile; of; of = of->next)
                           if (0 == strcmp(fn, of->fname))
                                   break;
   
                   if (NULL == of)
                           continue;
   
                   sseq = R_FIRST;
                   while (0 == (ch = (*db->seq)(db, &key, &val, sseq))) {
                           sseq = R_NEXT;
                           assert(sizeof(struct db_val) == val.size);
                           vbuf = val.data;
                           if (*maxrec != vbuf->rec)
                                   continue;
                           if (verb)
                                   printf("%s: Deleted keyword: %s\n",
                                                   fn, (char *)key.data);
                           ch = (*db->del)(db, &key, R_CURSOR);
                           if (ch < 0)
                                   break;
                   }
                   if (ch < 0) {
                           perror(dbf);
                           exit((int)MANDOCLEVEL_SYSERR);
                   }
   
                   if (verb)
                           printf("%s: Deleted index\n", fn);
   
                   val.size = 0;
                   ch = (*idx->put)(idx, &key, &val, R_CURSOR);
                   if (ch < 0) {
                           perror(idxf);
                           exit((int)MANDOCLEVEL_SYSERR);
                   }
   
                   if (reccur >= *recsz) {
                           *recsz += MANDOC_SLOP;
                           *recs = mandoc_realloc
                                   (*recs, *recsz * sizeof(recno_t));
                   }
   
                   (*recs)[(int)reccur] = *maxrec;
                   reccur++;
           }
           (*maxrec)++;
 }  }
   
 /*  /*
Line 648  pmdoc_An(MDOC_ARGS)
Line 711  pmdoc_An(MDOC_ARGS)
                 return;                  return;
   
         buf_appendmdoc(buf, n->child, 0);          buf_appendmdoc(buf, n->child, 0);
         hash_put(hash, buf, TYPE_AUTHOR);          hash_put(hash, buf, TYPE_An);
 }  }
   
 static void  static void
Line 659  hash_reset(DB **db)
Line 722  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 709  pmdoc_Fd(MDOC_ARGS)
Line 772  pmdoc_Fd(MDOC_ARGS)
         buf_appendb(buf, start, (size_t)(end - start + 1));          buf_appendb(buf, start, (size_t)(end - start + 1));
         buf_appendb(buf, "", 1);          buf_appendb(buf, "", 1);
   
         hash_put(hash, buf, TYPE_INCLUDES);          hash_put(hash, buf, TYPE_In);
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
Line 721  pmdoc_Cd(MDOC_ARGS)
Line 784  pmdoc_Cd(MDOC_ARGS)
                 return;                  return;
   
         buf_appendmdoc(buf, n->child, 0);          buf_appendmdoc(buf, n->child, 0);
         hash_put(hash, buf, TYPE_CONFIG);          hash_put(hash, buf, TYPE_Cd);
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
Line 735  pmdoc_In(MDOC_ARGS)
Line 798  pmdoc_In(MDOC_ARGS)
                 return;                  return;
   
         buf_append(buf, n->child->string);          buf_append(buf, n->child->string);
         hash_put(hash, buf, TYPE_INCLUDES);          hash_put(hash, buf, TYPE_In);
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
Line 761  pmdoc_Fn(MDOC_ARGS)
Line 824  pmdoc_Fn(MDOC_ARGS)
                 cp++;                  cp++;
   
         buf_append(buf, cp);          buf_append(buf, cp);
         hash_put(hash, buf, TYPE_FUNCTION);          hash_put(hash, buf, TYPE_Fn);
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
Line 775  pmdoc_St(MDOC_ARGS)
Line 838  pmdoc_St(MDOC_ARGS)
                 return;                  return;
   
         buf_append(buf, n->child->string);          buf_append(buf, n->child->string);
         hash_put(hash, buf, TYPE_STANDARD);          hash_put(hash, buf, TYPE_St);
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
Line 794  pmdoc_Xr(MDOC_ARGS)
Line 857  pmdoc_Xr(MDOC_ARGS)
         } else          } else
                 buf_appendb(buf, ".", 2);                  buf_appendb(buf, ".", 2);
   
         hash_put(hash, buf, TYPE_XREF);          hash_put(hash, buf, TYPE_Xr);
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
Line 831  pmdoc_Vt(MDOC_ARGS)
Line 894  pmdoc_Vt(MDOC_ARGS)
   
         buf_appendb(buf, start, sz);          buf_appendb(buf, start, sz);
         buf_appendb(buf, "", 1);          buf_appendb(buf, "", 1);
         hash_put(hash, buf, TYPE_VARIABLE);          hash_put(hash, buf, TYPE_Va);
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
Line 845  pmdoc_Fo(MDOC_ARGS)
Line 908  pmdoc_Fo(MDOC_ARGS)
                 return;                  return;
   
         buf_append(buf, n->child->string);          buf_append(buf, n->child->string);
         hash_put(hash, buf, TYPE_FUNCTION);          hash_put(hash, buf, TYPE_Fn);
 }  }
   
   
Line 860  pmdoc_Nd(MDOC_ARGS)
Line 923  pmdoc_Nd(MDOC_ARGS)
         buf_appendmdoc(dbuf, n->child, 1);          buf_appendmdoc(dbuf, n->child, 1);
         buf_appendmdoc(buf, n->child, 0);          buf_appendmdoc(buf, n->child, 0);
   
         hash_put(hash, buf, TYPE_DESC);          hash_put(hash, buf, TYPE_Nd);
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
Line 872  pmdoc_Er(MDOC_ARGS)
Line 935  pmdoc_Er(MDOC_ARGS)
                 return;                  return;
   
         buf_appendmdoc(buf, n->child, 0);          buf_appendmdoc(buf, n->child, 0);
         hash_put(hash, buf, TYPE_ERR);          hash_put(hash, buf, TYPE_Er);
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
Line 884  pmdoc_Ev(MDOC_ARGS)
Line 947  pmdoc_Ev(MDOC_ARGS)
                 return;                  return;
   
         buf_appendmdoc(buf, n->child, 0);          buf_appendmdoc(buf, n->child, 0);
         hash_put(hash, buf, TYPE_ENV);          hash_put(hash, buf, TYPE_Ev);
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
Line 896  pmdoc_Pa(MDOC_ARGS)
Line 959  pmdoc_Pa(MDOC_ARGS)
                 return;                  return;
   
         buf_appendmdoc(buf, n->child, 0);          buf_appendmdoc(buf, n->child, 0);
         hash_put(hash, buf, TYPE_PATH);          hash_put(hash, buf, TYPE_Pa);
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
Line 906  pmdoc_Nm(MDOC_ARGS)
Line 969  pmdoc_Nm(MDOC_ARGS)
   
         if (SEC_NAME == n->sec) {          if (SEC_NAME == n->sec) {
                 buf_appendmdoc(buf, n->child, 0);                  buf_appendmdoc(buf, n->child, 0);
                 hash_put(hash, buf, TYPE_NAME);                  hash_put(hash, buf, TYPE_Nm);
                 return;                  return;
         } else if (SEC_SYNOPSIS != n->sec || MDOC_HEAD != n->type)          } else if (SEC_SYNOPSIS != n->sec || MDOC_HEAD != n->type)
                 return;                  return;
Line 915  pmdoc_Nm(MDOC_ARGS)
Line 978  pmdoc_Nm(MDOC_ARGS)
                 buf_append(buf, m->name);                  buf_append(buf, m->name);
   
         buf_appendmdoc(buf, n->child, 0);          buf_appendmdoc(buf, n->child, 0);
         hash_put(hash, buf, TYPE_UTILITY);          hash_put(hash, buf, TYPE_Nm);
 }  }
   
 static void  static void
 hash_put(DB *db, const struct buf *buf, int mask)  hash_put(DB *db, const struct buf *buf, uint64_t mask)
 {  {
         DBT              key, val;          DBT              key, val;
         int              rc;          int              rc;
Line 934  hash_put(DB *db, const struct buf *buf, int mask)
Line 997  hash_put(DB *db, const struct buf *buf, int mask)
                 perror("hash");                  perror("hash");
                 exit((int)MANDOCLEVEL_SYSERR);                  exit((int)MANDOCLEVEL_SYSERR);
         } else if (0 == rc)          } else if (0 == rc)
                 mask |= *(int *)val.data;                  mask |= *(uint64_t *)val.data;
   
         val.data = &mask;          val.data = &mask;
         val.size = sizeof(int);          val.size = sizeof(uint64_t);
   
         if ((rc = (*db->put)(db, &key, &val, 0)) < 0) {          if ((rc = (*db->put)(db, &key, &val, 0)) < 0) {
                 perror("hash");                  perror("hash");
Line 1045  pman_node(MAN_ARGS)
Line 1108  pman_node(MAN_ARGS)
                                 buf_appendb(buf, start, sz);                                  buf_appendb(buf, start, sz);
                                 buf_appendb(buf, "", 1);                                  buf_appendb(buf, "", 1);
   
                                 hash_put(hash, buf, TYPE_NAME);                                  hash_put(hash, buf, TYPE_Nm);
   
                                 if (' ' == start[(int)sz]) {                                  if (' ' == start[(int)sz]) {
                                         start += (int)sz + 1;                                          start += (int)sz + 1;
Line 1084  pman_node(MAN_ARGS)
Line 1147  pman_node(MAN_ARGS)
                         buf_appendb(dbuf, start, sz);                          buf_appendb(dbuf, start, sz);
                         buf_appendb(buf, start, sz);                          buf_appendb(buf, start, sz);
   
                         hash_put(hash, buf, TYPE_DESC);                          hash_put(hash, buf, TYPE_Nd);
                 }                  }
         }          }
   
         if (pman_node(hash, buf, dbuf, n->child))          for (n = n->child; n; n = n->next)
                 return(1);                  if (pman_node(hash, buf, dbuf, n))
         if (pman_node(hash, buf, dbuf, n->next))                          return(1);
                 return(1);  
   
         return(0);          return(0);
 }  }
   
 static void  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.
    * We use this instead of ftw() and so on because I don't want global
    * variables hanging around.
    * This ignores the mandoc.db and mandoc.index files, but assumes that
    * everything else is a manual.
    * Pass in a pointer to a NULL structure for the first invocation.
    */
   static int
   ofile_dirbuild(const char *dir, int verb, struct of **of)
   {
           char             buf[MAXPATHLEN];
           size_t           sz;
           DIR             *d;
           const char      *fn;
           struct of       *nof;
           struct dirent   *dp;
   
           if (NULL == (d = opendir(dir))) {
                   perror(dir);
                   return(0);
           }
   
           while (NULL != (dp = readdir(d))) {
                   fn = dp->d_name;
                   if (DT_DIR == dp->d_type) {
                           if (0 == strcmp(".", fn))
                                   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);
                                   continue;
                           } else if (sz < MAXPATHLEN)
                                   continue;
   
                           fprintf(stderr, "%s: Path too long\n", dir);
                           return(0);
                   }
                   if (DT_REG != dp->d_type)
                           continue;
   
                   if (0 == strcmp(MANDOC_DB, fn) ||
                                   0 == strcmp(MANDOC_IDX, fn))
                           continue;
   
                   buf[0] = '\0';
                   strlcat(buf, dir, MAXPATHLEN);
                   strlcat(buf, "/", MAXPATHLEN);
                   sz = 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->fname = mandoc_strdup(buf);
   
                   if (verb > 2)
                           printf("%s: Scheduling\n", buf);
   
                   if (NULL == *of) {
                           *of = nof;
                           (*of)->first = nof;
                   } else {
                           nof->first = (*of)->first;
                           (*of)->next = nof;
                           *of = nof;
                   }
           }
   
           closedir(d);
           return(1);
   }
   
   static void
   ofile_free(struct of *of)
   {
           struct of       *nof;
   
           while (of) {
                   nof = of->next;
                   free(of->fname);
                   free(of);
                   of = nof;
           }
   }
   
   static void
 usage(void)  usage(void)
 {  {
   
         fprintf(stderr, "usage: %s [-ruv] [-d path] [file...]\n",          fprintf(stderr, "usage: %s [-v] "
                         progname);                          "[-d dir [files...] |"
                           " -u dir [files...] |"
                           " dir...]\n", progname);
 }  }
Legend:
Removed from v.1.2  
changed lines
  Added in v.1.9
CVSweb