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

Diff for /mandoc/Attic/mandoc-db.c between version 1.2 and 1.3

version 1.2, 2011/04/03 10:14:45 version 1.3, 2011/04/03 14:18:29
Line 38 
Line 38 
 #include "mandoc.h"  #include "mandoc.h"
   
 #define MANDOC_DB        "mandoc.db"  #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
   
 enum    type {  enum    type {
         MANDOC_NONE = 0,          MANDOC_NONE = 0,
Line 62  static void    dbt_init(DBT *, size_t *);
Line 64  static void    dbt_init(DBT *, size_t *);
 static  void              version(void);  static  void              version(void);
 static  void              usage(void);  static  void              usage(void);
 static  void              pmdoc(DB *, const char *,  static  void              pmdoc(DB *, const char *,
                                 DBT *, size_t *,                                  DBT *, size_t *, DBT *,
                                 DBT *, size_t *,  
                                 const char *, struct mdoc *);                                  const char *, struct mdoc *);
 static  void              pmdoc_node(MDOC_ARGS);  static  void              pmdoc_node(MDOC_ARGS);
 static  void              pmdoc_Fd(MDOC_ARGS);  static  void              pmdoc_Fd(MDOC_ARGS);
Line 207  main(int argc, char *argv[])
Line 208  main(int argc, char *argv[])
 {  {
         struct mparse   *mp; /* parse sequence */          struct mparse   *mp; /* parse sequence */
         struct mdoc     *mdoc; /* resulting mdoc */          struct mdoc     *mdoc; /* resulting mdoc */
         const char      *fn,          char            *fn;
                         *dir; /* result dir (default: cwd) */          const char      *dir; /* result dir (default: cwd) */
         char             fbuf[MAXPATHLEN],  /* btree fname */          char             ibuf[MAXPATHLEN], /* index fname */
                            ibbuf[MAXPATHLEN], /* index backup fname */
                            fbuf[MAXPATHLEN],  /* btree fname */
                          fbbuf[MAXPATHLEN]; /* btree backup fname */                           fbbuf[MAXPATHLEN]; /* btree backup fname */
         int              c;          int              c;
         DB              *db; /* open database */          DB              *index, /* index database */
         DBT              key, val; /* persistent entries */                          *db; /* keyword database */
         size_t           ksz, vsz; /* entry buffer sizes */          DBT              rkey, rval, /* recno entries */
                            key, val; /* persistent keyword entries */
           size_t           ksz; /* entry buffer size */
           char             vbuf[8];
         BTREEINFO        info; /* btree configuration */          BTREEINFO        info; /* btree configuration */
           recno_t          rec;
         extern int       optind;          extern int       optind;
         extern char     *optarg;          extern char     *optarg;
   
Line 225  main(int argc, char *argv[])
Line 232  main(int argc, char *argv[])
         else          else
                 ++progname;                  ++progname;
   
         dir = "./";          dir = "";
   
         while (-1 != (c = getopt(argc, argv, "d:V")))          while (-1 != (c = getopt(argc, argv, "d:V")))
                 switch (c) {                  switch (c) {
Line 244  main(int argc, char *argv[])
Line 251  main(int argc, char *argv[])
         argv += optind;          argv += optind;
   
         /*          /*
          * Set up a temporary file-name into which we're going to write           * Set up temporary file-names into which we're going to write
          * all of our data.  This is securely renamed to the real           * all of our data (both for the index and database).  These
          * file-name after we've written all of our data.           * will be securely renamed to the real file-names after we've
            * written all of our data.
          */           */
   
         fbuf[0] = fbuf[MAXPATHLEN - 2] =          ibuf[0] = ibuf[MAXPATHLEN - 2] =
                 fbbuf[0] = fbbuf[MAXPATHLEN - 1] = '\0';                  ibbuf[0] = ibbuf[MAXPATHLEN - 2] =
                   fbuf[0] = fbuf[MAXPATHLEN - 2] =
                   fbbuf[0] = fbbuf[MAXPATHLEN - 2] = '\0';
   
         strlcat(fbuf, dir, MAXPATHLEN);          strlcat(fbuf, dir, MAXPATHLEN);
         strlcat(fbuf, MANDOC_DB, MAXPATHLEN);          strlcat(fbuf, MANDOC_DB, MAXPATHLEN);
   
         strlcat(fbbuf, fbuf, MAXPATHLEN);          strlcat(fbbuf, fbuf, MAXPATHLEN);
         strlcat(fbbuf, "~", MAXPATHLEN);          strlcat(fbbuf, "~", MAXPATHLEN);
   
           strlcat(ibuf, dir, MAXPATHLEN);
           strlcat(ibuf, MANDOC_IDX, MAXPATHLEN);
   
           strlcat(ibbuf, ibuf, MAXPATHLEN);
           strlcat(ibbuf, "~", MAXPATHLEN);
   
         if ('\0' != fbuf[MAXPATHLEN - 2] ||          if ('\0' != fbuf[MAXPATHLEN - 2] ||
                         '\0' != fbbuf[MAXPATHLEN - 2]) {                          '\0' != fbbuf[MAXPATHLEN - 2] ||
                 fprintf(stderr, "%s: Bad filename\n", progname);                          '\0' != ibuf[MAXPATHLEN - 2] ||
                           '\0' != ibbuf[MAXPATHLEN - 2]) {
                   fprintf(stderr, "%s: Path too long\n", progname);
                 exit((int)MANDOCLEVEL_SYSERR);                  exit((int)MANDOCLEVEL_SYSERR);
         }          }
   
         /*          /*
          * Open a BTREE database that allows duplicates.  If the           * For the keyword database, open a BTREE database that allows
          * database already exists (it's a backup anyway), then blow it           * duplicates.  For the index database, use a standard RECNO
          * away with O_TRUNC.           * database type.
          */           */
   
         memset(&info, 0, sizeof(BTREEINFO));          memset(&info, 0, sizeof(BTREEINFO));
         info.flags = R_DUP;          info.flags = R_DUP;
           db = dbopen(fbbuf, MANDOC_FLAGS, 0644, DB_BTREE, &info);
   
         db = dbopen(fbbuf, O_CREAT|O_TRUNC|O_RDWR,  
                         0644, DB_BTREE, &info);  
   
         if (NULL == db) {          if (NULL == db) {
                 perror(fbbuf);                  perror(fbbuf);
                 exit((int)MANDOCLEVEL_SYSERR);                  exit((int)MANDOCLEVEL_SYSERR);
         }          }
   
         /* Use the auto-parser and don't report any errors. */          index = dbopen(ibbuf, MANDOC_FLAGS, 0644, DB_RECNO, NULL);
   
         mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);          if (NULL == db) {
                   perror(ibbuf);
                   (*db->close)(db);
                   exit((int)MANDOCLEVEL_SYSERR);
           }
   
         /*          /*
          * Try parsing the manuals given on the command line.  If we           * Try parsing the manuals given on the command line.  If we
          * totally fail, then just keep on going.  Take resulting trees           * totally fail, then just keep on going.  Take resulting trees
          * and push them down into the database code.           * and push them down into the database code.
            * Use the auto-parser and don't report any errors.
          */           */
   
           mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);
   
         memset(&key, 0, sizeof(DBT));          memset(&key, 0, sizeof(DBT));
         memset(&val, 0, sizeof(DBT));          memset(&val, 0, sizeof(DBT));
         ksz = vsz = 0;          memset(&rkey, 0, sizeof(DBT));
           memset(&rval, 0, sizeof(DBT));
   
           val.size = sizeof(vbuf);
           val.data = vbuf;
           rkey.size = sizeof(recno_t);
   
           rec = 1;
           ksz = 0;
   
         while (NULL != (fn = *argv++)) {          while (NULL != (fn = *argv++)) {
                 mparse_reset(mp);                  mparse_reset(mp);
   
                 if (mparse_readfd(mp, -1, fn) >= MANDOCLEVEL_FATAL)                  if (mparse_readfd(mp, -1, fn) >= MANDOCLEVEL_FATAL)
                         continue;                          continue;
   
                 mparse_result(mp, &mdoc, NULL);                  mparse_result(mp, &mdoc, NULL);
                 if (mdoc)                  if (NULL == mdoc)
                         pmdoc(db, fbbuf, &key, &ksz,                          continue;
                                 &val, &vsz, fn, mdoc);  
                   rkey.data = &rec;
                   rval.data = fn;
                   rval.size = strlen(fn) + 1;
   
                   if (-1 == (*index->put)(index, &rkey, &rval, 0)) {
                           perror(ibbuf);
                           break;
                   }
   
                   memset(val.data, 0, sizeof(uint32_t));
                   memcpy(val.data + 4, &rec, sizeof(uint32_t));
   
                   pmdoc(db, fbbuf, &key, &ksz, &val, fn, mdoc);
                   rec++;
         }          }
   
         (*db->close)(db);          (*db->close)(db);
           (*index->close)(index);
   
         mparse_free(mp);          mparse_free(mp);
   
         free(key.data);          free(key.data);
         free(val.data);  
   
         /* Atomically replace the file with our temporary one. */          /* Atomically replace the file with our temporary one. */
   
         if (-1 == rename(fbbuf, fbuf))          if (-1 == rename(fbbuf, fbuf))
                 perror(fbuf);                  perror(fbuf);
           if (-1 == rename(ibbuf, ibuf))
                   perror(fbuf);
   
         return((int)MANDOCLEVEL_OK);          return((int)MANDOCLEVEL_OK);
 }  }
Line 351  dbt_appendb(DBT *key, size_t *ksz, const void *cp, siz
Line 402  dbt_appendb(DBT *key, size_t *ksz, const void *cp, siz
   
         while (key->size + sz >= *ksz) {          while (key->size + sz >= *ksz) {
                 *ksz = key->size + sz + MANDOC_BUFSZ;                  *ksz = key->size + sz + MANDOC_BUFSZ;
                 *ksz = *ksz + (4 - (*ksz % 4));  
                 key->data = mandoc_realloc(key->data, *ksz);                  key->data = mandoc_realloc(key->data, *ksz);
         }          }
   
Line 369  dbt_append(DBT *key, size_t *ksz, const char *cp)
Line 419  dbt_append(DBT *key, size_t *ksz, const char *cp)
 {  {
         size_t           sz;          size_t           sz;
   
         assert(key->data);  
         assert(key->size <= *ksz);  
   
         if (0 == (sz = strlen(cp)))          if (0 == (sz = strlen(cp)))
                 return;                  return;
   
         /* Overshoot by MANDOC_BUFSZ (and nil terminator). */          assert(key->data);
   
         while (key->size + sz + 1 >= *ksz) {  
                 *ksz = key->size + sz + 1 + MANDOC_BUFSZ;  
                 *ksz = *ksz + (4 - (*ksz % 4));  
                 key->data = mandoc_realloc(key->data, *ksz);  
         }  
   
         /* Space-separate appended tokens. */  
   
         if (key->size)          if (key->size)
                 ((char *)key->data)[(int)key->size - 1] = ' ';                  ((char *)key->data)[(int)key->size - 1] = ' ';
   
         memcpy(key->data + (int)key->size, cp, sz + 1);          dbt_appendb(key, ksz, cp, sz + 1);
         key->size += sz + 1;  
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
Line 604  pmdoc_node(MDOC_ARGS)
Line 642  pmdoc_node(MDOC_ARGS)
   
 static void  static void
 pmdoc(DB *db, const char *dbn,  pmdoc(DB *db, const char *dbn,
                 DBT *key, size_t *ksz,                  DBT *key, size_t *ksz, DBT *val,
                 DBT *val, size_t *valsz,  
                 const char *path, struct mdoc *m)                  const char *path, struct mdoc *m)
 {  {
         uint32_t         flag;  
   
         flag = MANDOC_NONE;  
   
         /*  
          * Database values are a 4-byte bit-field followed by the path  
          * of the manual.  Allocate all the space we'll need now; we  
          * change the bit-field depending on the key type.  
          */  
   
         dbt_init(val, valsz);  
         dbt_appendb(val, valsz, &flag, 4);  
         dbt_append(val, valsz, path);  
   
         pmdoc_node(db, dbn, key, ksz, val, mdoc_node(m));          pmdoc_node(db, dbn, key, ksz, val, mdoc_node(m));
 }  }
Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3
CVSweb