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

Diff for /mandoc/mandocdb.c between version 1.7 and 1.10

version 1.7, 2011/11/13 00:53:13 version 1.10, 2011/11/23 09:52:20
Line 38 
Line 38 
 #include "man.h"  #include "man.h"
 #include "mdoc.h"  #include "mdoc.h"
 #include "mandoc.h"  #include "mandoc.h"
   #include "mandocdb.h"
   #include "manpath.h"
   
 #define MANDOC_DB        "mandoc.db"  
 #define MANDOC_IDX       "mandoc.index"  
 #define MANDOC_BUFSZ      BUFSIZ  #define MANDOC_BUFSZ      BUFSIZ
 #define MANDOC_SLOP       1024  #define MANDOC_SLOP       1024
   
 /* Bit-fields.  See mandocdb.8. */  
   
 #define TYPE_NAME         0x01  
 #define TYPE_FUNCTION     0x02  
 #define TYPE_UTILITY      0x04  
 #define TYPE_INCLUDES     0x08  
 #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  
   
 /* Tiny list for files.  No need to bring in QUEUE. */  /* Tiny list for files.  No need to bring in QUEUE. */
   
 struct  of {  struct  of {
Line 100  static void    buf_append(struct buf *, const char *);
Line 84  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 *,  static  void              index_merge(const struct of *, struct mparse *,
                                 struct buf *, struct buf *,                                  struct buf *, struct buf *,
Line 264  int
Line 248  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
         struct mparse   *mp; /* parse sequence */          struct mparse   *mp; /* parse sequence */
           struct manpaths  dirs;
         enum op          op; /* current operation */          enum op          op; /* current operation */
         const char      *dir;          const char      *dir;
         char             ibuf[MAXPATHLEN], /* index fname */          char             ibuf[MAXPATHLEN], /* index fname */
Line 291  main(int argc, char *argv[])
Line 276  main(int argc, char *argv[])
         else          else
                 ++progname;                  ++progname;
   
           memset(&dirs, 0, sizeof(struct manpaths));
   
         verb = 0;          verb = 0;
         of = NULL;          of = NULL;
         db = idx = NULL;          db = idx = NULL;
Line 387  main(int argc, char *argv[])
Line 374  main(int argc, char *argv[])
                 goto out;                  goto out;
         }          }
   
         for (i = 0; i < argc; i++) {          /*
            * Configure the directories we're going to scan.
            * If we have command-line arguments, use them.
            * If not, we use man(1)'s method (see mandocdb.8).
            */
   
           if (argc > 0) {
                   dirs.paths = mandoc_malloc(argc * sizeof(char *));
                   dirs.sz = argc;
                   for (i = 0; i < argc; i++)
                           dirs.paths[i] = mandoc_strdup(argv[i]);
           } else
                   manpath_parseconf(&dirs);
   
           for (i = 0; i < dirs.sz; i++) {
                 ibuf[0] = fbuf[0] = '\0';                  ibuf[0] = fbuf[0] = '\0';
   
                 strlcat(fbuf, argv[i], MAXPATHLEN);                  strlcat(fbuf, dirs.paths[i], MAXPATHLEN);
                 strlcat(fbuf, "/", MAXPATHLEN);                  strlcat(fbuf, "/", MAXPATHLEN);
                 sz1 = strlcat(fbuf, MANDOC_DB, MAXPATHLEN);                  sz1 = strlcat(fbuf, MANDOC_DB, MAXPATHLEN);
   
                 strlcat(ibuf, argv[i], MAXPATHLEN);                  strlcat(ibuf, dirs.paths[i], MAXPATHLEN);
                 strlcat(ibuf, "/", MAXPATHLEN);                  strlcat(ibuf, "/", MAXPATHLEN);
                 sz2 = strlcat(ibuf, MANDOC_IDX, MAXPATHLEN);                  sz2 = strlcat(ibuf, MANDOC_IDX, MAXPATHLEN);
   
                 if (sz1 >= MAXPATHLEN || sz2 >= MAXPATHLEN) {                  if (sz1 >= MAXPATHLEN || sz2 >= MAXPATHLEN) {
                         fprintf(stderr, "%s: Path too long\n", argv[i]);                          fprintf(stderr, "%s: Path too long\n",
                                           dirs.paths[i]);
                         exit((int)MANDOCLEVEL_BADARG);                          exit((int)MANDOCLEVEL_BADARG);
                 }                  }
   
Line 422  main(int argc, char *argv[])
Line 424  main(int argc, char *argv[])
                 ofile_free(of);                  ofile_free(of);
                 of = NULL;                  of = NULL;
   
                 if ( ! ofile_dirbuild(argv[i], verb, &of))                  if ( ! ofile_dirbuild(dirs.paths[i], verb, &of))
                         exit((int)MANDOCLEVEL_SYSERR);                          exit((int)MANDOCLEVEL_SYSERR);
   
                 if (NULL == of)                  if (NULL == of)
Line 444  out:
Line 446  out:
         if (mp)          if (mp)
                 mparse_free(mp);                  mparse_free(mp);
   
           manpath_free(&dirs);
         ofile_free(of);          ofile_free(of);
         free(buf.cp);          free(buf.cp);
         free(dbuf.cp);          free(dbuf.cp);
Line 467  index_merge(const struct of *of, struct mparse *mp,
Line 470  index_merge(const struct of *of, struct mparse *mp,
         const char      *fn, *msec, *mtitle, *arch;          const char      *fn, *msec, *mtitle, *arch;
         size_t           sv;          size_t           sv;
         unsigned         seq;          unsigned         seq;
         char             vbuf[8];          struct db_val    vbuf;
   
         for (rec = 0; of; of = of->next) {          for (rec = 0; of; of = of->next) {
                 fn = of->fname;                  fn = of->fname;
Line 530  index_merge(const struct of *of, struct mparse *mp,
Line 533  index_merge(const struct of *of, struct mparse *mp,
                  * 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\n",                                  printf("%s: Added keyword: %s\n",
Line 585  index_prune(const struct of *ofile, DB *db, const char
Line 586  index_prune(const struct of *ofile, DB *db, const char
 {  {
         const struct of *of;          const struct of *of;
         const char      *fn;          const char      *fn;
           struct db_val   *vbuf;
         unsigned         seq, sseq;          unsigned         seq, sseq;
         DBT              key, val;          DBT              key, val;
         size_t           reccur;          size_t           reccur;
Line 617  index_prune(const struct of *ofile, DB *db, const char
Line 619  index_prune(const struct of *ofile, DB *db, const char
                 sseq = R_FIRST;                  sseq = R_FIRST;
                 while (0 == (ch = (*db->seq)(db, &key, &val, sseq))) {                  while (0 == (ch = (*db->seq)(db, &key, &val, sseq))) {
                         sseq = R_NEXT;                          sseq = R_NEXT;
                         assert(8 == val.size);                          assert(sizeof(struct db_val) == val.size);
                         if (*maxrec != *(recno_t *)(val.data + 4))                          vbuf = val.data;
                           if (*maxrec != vbuf->rec)
                                 continue;                                  continue;
                         if (verb)                          if (verb)
                                 printf("%s: Deleted keyword: %s\n",                                  printf("%s: Deleted keyword: %s\n",
Line 728  pmdoc_An(MDOC_ARGS)
Line 731  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 789  pmdoc_Fd(MDOC_ARGS)
Line 792  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 801  pmdoc_Cd(MDOC_ARGS)
Line 804  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 815  pmdoc_In(MDOC_ARGS)
Line 818  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 841  pmdoc_Fn(MDOC_ARGS)
Line 844  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 855  pmdoc_St(MDOC_ARGS)
Line 858  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 874  pmdoc_Xr(MDOC_ARGS)
Line 877  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 911  pmdoc_Vt(MDOC_ARGS)
Line 914  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 925  pmdoc_Fo(MDOC_ARGS)
Line 928  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 940  pmdoc_Nd(MDOC_ARGS)
Line 943  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 952  pmdoc_Er(MDOC_ARGS)
Line 955  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 964  pmdoc_Ev(MDOC_ARGS)
Line 967  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 976  pmdoc_Pa(MDOC_ARGS)
Line 979  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 986  pmdoc_Nm(MDOC_ARGS)
Line 989  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 995  pmdoc_Nm(MDOC_ARGS)
Line 998  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 1014  hash_put(DB *db, const struct buf *buf, int mask)
Line 1017  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 1125  pman_node(MAN_ARGS)
Line 1128  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 1164  pman_node(MAN_ARGS)
Line 1167  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);
                 }                  }
         }          }
   
Legend:
Removed from v.1.7  
changed lines
  Added in v.1.10
CVSweb