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

Diff for /mandoc/Attic/makewhatis.c between version 1.4 and 1.5

version 1.4, 2011/06/21 13:13:15 version 1.5, 2011/06/21 13:54:05
Line 42 
Line 42 
 #define MANDOC_BUFSZ      BUFSIZ  #define MANDOC_BUFSZ      BUFSIZ
 #define MANDOC_FLAGS      O_CREAT|O_TRUNC|O_RDWR  #define MANDOC_FLAGS      O_CREAT|O_TRUNC|O_RDWR
   
   /* Bit-fields.  See makewhatis.1. */
   
 #define TYPE_NAME       0x01  #define TYPE_NAME       0x01
 #define TYPE_FUNCTION   0x02  #define TYPE_FUNCTION   0x02
 #define TYPE_UTILITY    0x04  #define TYPE_UTILITY    0x04
Line 52 
Line 54 
 #define TYPE_CONFIG     0x80  #define TYPE_CONFIG     0x80
 #define TYPE__MAX       TYPE_CONFIG  #define TYPE__MAX       TYPE_CONFIG
   
   /* Buffer for storing growable data. */
   
 struct  buf {  struct  buf {
         char             *cp;          char             *cp;
         size_t            len;          size_t            len;
Line 60  struct buf {
Line 64  struct buf {
   
 #define MAN_ARGS          DB *hash, \  #define MAN_ARGS          DB *hash, \
                           struct buf *buf, \                            struct buf *buf, \
                           DBT *rval, size_t *rsz, \                            struct buf *dbuf, \
                           const struct man_node *n                            const struct man_node *n
 #define MDOC_ARGS         DB *hash, \  #define MDOC_ARGS         DB *hash, \
                           struct buf *buf, \                            struct buf *buf, \
                           DBT *rval, size_t *rsz, \                            struct buf *dbuf, \
                           const struct mdoc_node *n, \                            const struct mdoc_node *n, \
                           const struct mdoc_meta *m                            const struct mdoc_meta *m
   
 static  void              dbt_append(DBT *, size_t *, const char *);  static  void              buf_append(struct buf *, const char *);
 static  void              dbt_appendb(DBT *, size_t *,  static  void              buf_appendb(struct buf *,
                                 const void *, size_t);                                  const void *, size_t);
 static  void              dbt_init(DBT *, 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 *, int);
 static  void              usage(void);  
 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 87  static void    pmdoc_Nd(MDOC_ARGS);
Line 89  static void    pmdoc_Nd(MDOC_ARGS);
 static  void              pmdoc_Nm(MDOC_ARGS);  static  void              pmdoc_Nm(MDOC_ARGS);
 static  void              pmdoc_St(MDOC_ARGS);  static  void              pmdoc_St(MDOC_ARGS);
 static  void              pmdoc_Vt(MDOC_ARGS);  static  void              pmdoc_Vt(MDOC_ARGS);
   static  void              usage(void);
   
 typedef void            (*pmdoc_nf)(MDOC_ARGS);  typedef void            (*pmdoc_nf)(MDOC_ARGS);
   
 static  const char       *progname;  
   
 static  const pmdoc_nf    mdocs[MDOC_MAX] = {  static  const pmdoc_nf    mdocs[MDOC_MAX] = {
         NULL, /* Ap */          NULL, /* Ap */
         NULL, /* Dd */          NULL, /* Dd */
Line 217  static const pmdoc_nf   mdocs[MDOC_MAX] = {
Line 218  static const pmdoc_nf   mdocs[MDOC_MAX] = {
         NULL, /* Ta */          NULL, /* Ta */
 };  };
   
   static  const char       *progname;
   
 int  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
Line 237  main(int argc, char *argv[])
Line 240  main(int argc, char *argv[])
         DB              *idx, /* index database */          DB              *idx, /* index database */
                         *db, /* keyword database */                          *db, /* keyword database */
                         *hash; /* temporary keyword hashtable */                          *hash; /* temporary keyword hashtable */
         DBT              rkey, rval, /* recno entries */          DBT              key, val;
                          key, val; /* persistent keyword entries */  
         size_t           sv, rsz;          size_t           sv, rsz;
         BTREEINFO        info; /* btree configuration */          BTREEINFO        info; /* btree configuration */
         recno_t          rec; /* current record number */          recno_t          rec; /* current record number */
         struct buf       buf; /* keyword buffer */          struct buf       buf, /* keyword buffer */
                            dbuf; /* description buffer */
         extern int       optind;          extern int       optind;
         extern char     *optarg;          extern char     *optarg;
   
Line 341  main(int argc, char *argv[])
Line 344  main(int argc, char *argv[])
   
         mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);          mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);
   
         memset(&key, 0, sizeof(DBT));  
         memset(&val, 0, sizeof(DBT));  
         memset(&rkey, 0, sizeof(DBT));  
         memset(&rval, 0, sizeof(DBT));  
   
         rkey.size = sizeof(recno_t);  
   
         rec = 1;          rec = 1;
         rsz = 0;          rsz = 0;
   
         memset(&buf, 0, sizeof(struct buf));          memset(&buf, 0, sizeof(struct buf));
           memset(&dbuf, 0, sizeof(struct buf));
   
         buf.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);
   
         while (NULL != (fn = *argv++)) {          while (NULL != (fn = *argv++)) {
                 mparse_reset(mp);                  mparse_reset(mp);
Line 390  main(int argc, char *argv[])
Line 389  main(int argc, char *argv[])
                  * going to write a nil byte in its place.                   * going to write a nil byte in its place.
                  */                   */
   
                 dbt_init(&rval, &rsz);                  dbuf.len = 0;
                 dbt_appendb(&rval, &rsz, fn, strlen(fn) + 1);                  buf_appendb(&dbuf, fn, strlen(fn) + 1);
                 dbt_appendb(&rval, &rsz, msec, strlen(msec) + 1);                  buf_appendb(&dbuf, msec, strlen(msec) + 1);
                 dbt_appendb(&rval, &rsz, mtitle, strlen(mtitle) + 1);                  buf_appendb(&dbuf, mtitle, strlen(mtitle) + 1);
                 dbt_appendb(&rval, &rsz, arch ? arch : "",                  buf_appendb(&dbuf, arch ? arch : "",
                                 arch ? strlen(arch) + 1 : 1);                                  arch ? strlen(arch) + 1 : 1);
   
                 sv = rval.size;                  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, &rval,                          pmdoc_node(hash, &buf, &dbuf,
                                         &rsz, mdoc_node(mdoc),                                  mdoc_node(mdoc), mdoc_meta(mdoc));
                                         mdoc_meta(mdoc));  
                 else                  else
                         pman_node(hash, &buf, &rval,                          pman_node(hash, &buf, &dbuf, man_node(man));
                                         &rsz, man_node(man));  
   
                 /*                  /*
                  * Copy from the in-memory hashtable of pending keywords                   * Copy from the in-memory hashtable of pending keywords
Line 423  main(int argc, char *argv[])
Line 420  main(int argc, char *argv[])
                         val.size = sizeof(vbuf);                          val.size = sizeof(vbuf);
                         val.data = vbuf;                          val.data = vbuf;
                         dbt_put(db, fbbuf, &key, &val);                          dbt_put(db, fbbuf, &key, &val);
                         /*fprintf(stderr, "Recording: %s (0x%x)\n",  
                                         (char *)key.data,  
                                         *(int *)val.data);*/  
                         if ((*hash->del)(hash, &key, 0) < 0) {                          if ((*hash->del)(hash, &key, 0) < 0) {
                                 perror("hash");                                  perror("hash");
                                 exit((int)MANDOCLEVEL_SYSERR);                                  exit((int)MANDOCLEVEL_SYSERR);
Line 443  main(int argc, char *argv[])
Line 438  main(int argc, char *argv[])
                  * set, put an empty one in now.                   * set, put an empty one in now.
                  */                   */
   
                 if (rval.size == sv)                  if (dbuf.len == sv)
                         dbt_appendb(&rval, &rsz, "", 1);                          buf_appendb(&dbuf, "", 1);
   
                 rkey.data = &rec;                  key.data = &rec;
                 dbt_put(idx, ibbuf, &rkey, &rval);                  key.size = sizeof(recno_t);
   
                 printf("Indexed: %s\n", fn);                  val.data = dbuf.cp;
                   val.size = dbuf.len;
   
                   dbt_put(idx, ibbuf, &key, &val);
                 rec++;                  rec++;
         }          }
   
Line 459  main(int argc, char *argv[])
Line 457  main(int argc, char *argv[])
   
         mparse_free(mp);          mparse_free(mp);
   
         free(rval.data);  
         free(buf.cp);          free(buf.cp);
           free(dbuf.cp);
   
         /* Atomically replace the file with our temporary one. */          /* Atomically replace the file with our temporary one. */
   
Line 473  main(int argc, char *argv[])
Line 471  main(int argc, char *argv[])
 }  }
   
 /*  /*
  * Initialise the stored database key whose data buffer is shared   * Grow the buffer (if necessary) and copy in a binary string.
  * between uses (as the key must sometimes be constructed from an array  
  * of  
  */   */
 static void  static void
 dbt_init(DBT *key, size_t *ksz)  
 {  
   
         if (0 == *ksz) {  
                 assert(0 == key->size);  
                 assert(NULL == key->data);  
                 key->data = mandoc_malloc(MANDOC_BUFSZ);  
                 *ksz = MANDOC_BUFSZ;  
         }  
   
         key->size = 0;  
 }  
   
 /*  
  * Append a binary value to a database entry.  This can be invoked  
  * multiple times; the buffer is automatically resized.  
  */  
 static void  
 dbt_appendb(DBT *key, size_t *ksz, const void *cp, size_t sz)  
 {  
   
         assert(key->data);  
   
         /* Overshoot by MANDOC_BUFSZ. */  
   
         while (key->size + sz >= *ksz) {  
                 *ksz = key->size + sz + MANDOC_BUFSZ;  
                 key->data = mandoc_realloc(key->data, *ksz);  
         }  
   
         memcpy(key->data + (int)key->size, cp, sz);  
         key->size += sz;  
 }  
   
 static void  
 buf_appendb(struct buf *buf, const void *cp, size_t sz)  buf_appendb(struct buf *buf, const void *cp, size_t sz)
 {  {
   
Line 528  buf_appendb(struct buf *buf, const void *cp, size_t sz
Line 489  buf_appendb(struct buf *buf, const void *cp, size_t sz
 }  }
   
 /*  /*
  * Append a nil-terminated string to the database entry.  This can be   * Append a nil-terminated string to the buffer.
  * invoked multiple times.  The database entry will be nil-terminated as   * This can be invoked multiple times.
  * well; if invoked multiple times, a space is put between strings.   * The buffer string will be nil-terminated.
    * If invoked multiple times, a space is put between strings.
  */   */
 static void  static void
 dbt_append(DBT *key, size_t *ksz, const char *cp)  
 {  
         size_t           sz;  
   
         if (0 == (sz = strlen(cp)))  
                 return;  
   
         assert(key->data);  
   
         if (key->size)  
                 ((char *)key->data)[(int)key->size - 1] = ' ';  
   
         dbt_appendb(key, ksz, cp, sz + 1);  
 }  
   
 static void  
 buf_append(struct buf *buf, const char *cp)  buf_append(struct buf *buf, const char *cp)
 {  {
         size_t           sz;          size_t           sz;
Line 754  pmdoc_Nd(MDOC_ARGS)
Line 700  pmdoc_Nd(MDOC_ARGS)
                 if (MDOC_TEXT != n->type)                  if (MDOC_TEXT != n->type)
                         continue;                          continue;
                 if (first)                  if (first)
                         dbt_appendb(rval, rsz, n->string, strlen(n->string) + 1);                          buf_appendb(dbuf, n->string, strlen(n->string) + 1);
                 else                  else
                         dbt_append(rval, rsz, n->string);                          buf_append(dbuf, n->string);
                 first = 0;                  first = 0;
         }          }
 }  }
Line 821  dbt_put(DB *db, const char *dbn, DBT *key, DBT *val)
Line 767  dbt_put(DB *db, const char *dbn, DBT *key, DBT *val)
         if (0 == key->size)          if (0 == key->size)
                 return;                  return;
   
         assert(key->data);          assert(key->size);
         assert(val->size);          assert(val->size);
         assert(val->data);  
   
         if (0 == (*db->put)(db, key, val, 0))          if (0 == (*db->put)(db, key, val, 0))
                 return;                  return;
Line 858  pmdoc_node(MDOC_ARGS)
Line 803  pmdoc_node(MDOC_ARGS)
                         break;                          break;
   
                 buf->len = 0;                  buf->len = 0;
                 (*mdocs[n->tok])(hash, buf, rval, rsz, n, m);                  (*mdocs[n->tok])(hash, buf, dbuf, n, m);
                 break;                  break;
         default:          default:
                 break;                  break;
         }          }
   
         pmdoc_node(hash, buf, rval, rsz, n->child, m);          pmdoc_node(hash, buf, dbuf, n->child, m);
         pmdoc_node(hash, buf, rval, rsz, n->next, m);          pmdoc_node(hash, buf, dbuf, n->next, m);
 }  }
   
 static int  static int
Line 952  pman_node(MAN_ARGS)
Line 897  pman_node(MAN_ARGS)
                         while (' ' == *start)                          while (' ' == *start)
                                 start++;                                  start++;
   
                         dbt_appendb(rval, rsz, start, strlen(start) + 1);                          buf_appendb(dbuf, start, strlen(start) + 1);
                 }                  }
         }          }
   
         if (pman_node(hash, buf, rval, rsz, n->child))          if (pman_node(hash, buf, dbuf, n->child))
                 return(1);                  return(1);
         if (pman_node(hash, buf, rval, rsz, n->next))          if (pman_node(hash, buf, dbuf, n->next))
                 return(1);                  return(1);
   
         return(0);          return(0);
Line 968  static void
Line 913  static void
 usage(void)  usage(void)
 {  {
   
         fprintf(stderr, "usage: %s "          fprintf(stderr, "usage: %s [-d path] [file...]\n", progname);
                         "[-d path] "  
                         "[file...]\n",  
                         progname);  
 }  }
Legend:
Removed from v.1.4  
changed lines
  Added in v.1.5
CVSweb