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

Diff for /mandoc/Attic/makewhatis.c between version 1.2 and 1.14

version 1.2, 2011/05/15 02:47:17 version 1.14, 2011/07/01 10:46:32
Line 21 
Line 21 
 #include <sys/param.h>  #include <sys/param.h>
   
 #include <assert.h>  #include <assert.h>
 #ifdef __linux__  
 # include <db_185.h>  
 #else  
 # include <db.h>  
 #endif  
 #include <fcntl.h>  #include <fcntl.h>
 #include <getopt.h>  #include <getopt.h>
 #include <stdio.h>  #include <stdio.h>
Line 33 
Line 28 
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
   
   #ifdef __linux__
   # include <db_185.h>
   #else
   # include <db.h>
   #endif
   
 #include "man.h"  #include "man.h"
 #include "mdoc.h"  #include "mdoc.h"
 #include "mandoc.h"  #include "mandoc.h"
Line 42 
Line 43 
 #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
   
 enum    type {  /* Bit-fields.  See makewhatis.1. */
         MANDOC_NONE = 0,  
         MANDOC_NAME,  #define TYPE_NAME         0x01
         MANDOC_FUNCTION,  #define TYPE_FUNCTION     0x02
         MANDOC_UTILITY,  #define TYPE_UTILITY      0x04
         MANDOC_INCLUDES,  #define TYPE_INCLUDES     0x08
         MANDOC_VARIABLE,  #define TYPE_VARIABLE     0x10
         MANDOC_STANDARD,  #define TYPE_STANDARD     0x20
         MANDOC_AUTHOR,  #define TYPE_AUTHOR       0x40
         MANDOC_CONFIG  #define TYPE_CONFIG       0x80
   #define TYPE_DESC         0x100
   #define TYPE_XREF         0x200
   #define TYPE_PATH         0x400
   
   /* Buffer for storing growable data. */
   
   struct  buf {
           char             *cp;
           size_t            len;
           size_t            size;
 };  };
   
 #define MAN_ARGS          DB *db, \  #define MAN_ARGS          DB *hash, \
                           const char *dbn, \                            struct buf *buf, \
                           DBT *key, size_t *ksz, \                            struct buf *dbuf, \
                           DBT *val, \  
                           DBT *rval, size_t *rsz, \  
                           const struct man_node *n                            const struct man_node *n
 #define MDOC_ARGS         DB *db, \  #define MDOC_ARGS         DB *hash, \
                           const char *dbn, \                            struct buf *buf, \
                           DBT *key, size_t *ksz, \                            struct buf *dbuf, \
                           DBT *val, \                            const struct mdoc_node *n, \
                           DBT *rval, size_t *rsz, \                            const struct mdoc_meta *m
                           const struct mdoc_node *n  
   
 static  void              dbt_append(DBT *, size_t *, const char *);  static  void              buf_appendmdoc(struct buf *,
 static  void              dbt_appendb(DBT *, size_t *,                                  const struct mdoc_node *, int);
   static  void              buf_append(struct buf *, const char *);
   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              usage(void);  static  void              hash_put(DB *, const struct buf *, int);
 static  void              pman(DB *, const char *, DBT *, size_t *,  
                                 DBT *, DBT *, size_t *, struct man *);  
 static  int               pman_node(MAN_ARGS);  static  int               pman_node(MAN_ARGS);
 static  void              pmdoc(DB *, const char *, DBT *, size_t *,  
                                 DBT *, DBT *, size_t *, struct mdoc *);  
 static  void              pmdoc_node(MDOC_ARGS);  static  void              pmdoc_node(MDOC_ARGS);
 static  void              pmdoc_An(MDOC_ARGS);  static  void              pmdoc_An(MDOC_ARGS);
 static  void              pmdoc_Cd(MDOC_ARGS);  static  void              pmdoc_Cd(MDOC_ARGS);
Line 87  static void    pmdoc_Fn(MDOC_ARGS);
Line 92  static void    pmdoc_Fn(MDOC_ARGS);
 static  void              pmdoc_Fo(MDOC_ARGS);  static  void              pmdoc_Fo(MDOC_ARGS);
 static  void              pmdoc_Nd(MDOC_ARGS);  static  void              pmdoc_Nd(MDOC_ARGS);
 static  void              pmdoc_Nm(MDOC_ARGS);  static  void              pmdoc_Nm(MDOC_ARGS);
   static  void              pmdoc_Pa(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              pmdoc_Xr(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 130  static const pmdoc_nf   mdocs[MDOC_MAX] = {
Line 136  static const pmdoc_nf   mdocs[MDOC_MAX] = {
         pmdoc_Nm, /* Nm */          pmdoc_Nm, /* Nm */
         NULL, /* Op */          NULL, /* Op */
         NULL, /* Ot */          NULL, /* Ot */
         NULL, /* Pa */          pmdoc_Pa, /* Pa */
         NULL, /* Rv */          NULL, /* Rv */
         pmdoc_St, /* St */          pmdoc_St, /* St */
         pmdoc_Vt, /* Va */          pmdoc_Vt, /* Va */
         pmdoc_Vt, /* Vt */          pmdoc_Vt, /* Vt */
         NULL, /* Xr */          pmdoc_Xr, /* Xr */
         NULL, /* %A */          NULL, /* %A */
         NULL, /* %B */          NULL, /* %B */
         NULL, /* %D */          NULL, /* %D */
Line 219  static const pmdoc_nf   mdocs[MDOC_MAX] = {
Line 225  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 233  main(int argc, char *argv[])
Line 241  main(int argc, char *argv[])
         char             ibuf[MAXPATHLEN], /* index fname */          char             ibuf[MAXPATHLEN], /* index fname */
                          ibbuf[MAXPATHLEN], /* index backup fname */                           ibbuf[MAXPATHLEN], /* index backup fname */
                          fbuf[MAXPATHLEN],  /* btree fname */                           fbuf[MAXPATHLEN],  /* btree fname */
                          fbbuf[MAXPATHLEN]; /* btree backup fname */                           fbbuf[MAXPATHLEN], /* btree backup fname */
         int              ch;                           vbuf[8]; /* stringified record number */
           int              ch, seq, verb;
         DB              *idx, /* index database */          DB              *idx, /* index database */
                         *db; /* keyword database */                          *db, /* keyword database */
         DBT              rkey, rval, /* recno entries */                          *hash; /* temporary keyword hashtable */
                          key, val; /* persistent keyword entries */          DBT              key, val;
         size_t           sv,          size_t           sv;
                          ksz, rsz; /* entry buffer size */  
         char             vbuf[8]; /* stringified record number */  
         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 */
                            dbuf; /* description buffer */
         extern int       optind;          extern int       optind;
         extern char     *optarg;          extern char     *optarg;
   
Line 254  main(int argc, char *argv[])
Line 263  main(int argc, char *argv[])
                 ++progname;                  ++progname;
   
         dir = "";          dir = "";
           verb = 0;
   
         while (-1 != (ch = getopt(argc, argv, "d:")))          while (-1 != (ch = getopt(argc, argv, "d:v")))
                 switch (ch) {                  switch (ch) {
                 case ('d'):                  case ('d'):
                         dir = optarg;                          dir = optarg;
                         break;                          break;
                   case ('v'):
                           verb++;
                           break;
                 default:                  default:
                         usage();                          usage();
                         return((int)MANDOCLEVEL_BADARG);                          return((int)MANDOCLEVEL_BADARG);
Line 296  main(int argc, char *argv[])
Line 309  main(int argc, char *argv[])
                         '\0' != fbbuf[MAXPATHLEN - 2] ||                          '\0' != fbbuf[MAXPATHLEN - 2] ||
                         '\0' != ibuf[MAXPATHLEN - 2] ||                          '\0' != ibuf[MAXPATHLEN - 2] ||
                         '\0' != ibbuf[MAXPATHLEN - 2]) {                          '\0' != ibbuf[MAXPATHLEN - 2]) {
                 fprintf(stderr, "%s: Path too long\n", progname);                  fprintf(stderr, "%s: Path too long\n", dir);
                 exit((int)MANDOCLEVEL_SYSERR);                  exit((int)MANDOCLEVEL_SYSERR);
         }          }
   
         /*          /*
          * For the keyword database, open a BTREE database that allows           * For the keyword database, open a BTREE database that allows
          * duplicates.  For the index database, use a standard RECNO           * duplicates.
          * database type.           * For the index database, use a standard RECNO database type.
          */           */
   
         memset(&info, 0, sizeof(BTREEINFO));          memset(&info, 0, sizeof(BTREEINFO));
Line 324  main(int argc, char *argv[])
Line 337  main(int argc, char *argv[])
         }          }
   
         /*          /*
          * Try parsing the manuals given on the command line.  If we           * Try parsing each manual given on the command line.
          * totally fail, then just keep on going.  Take resulting trees           * If we fail, then emit an error and keep on going.
          * and push them down into the database code.           * Take resulting trees and push them down into the database code.
          * Use the auto-parser and don't report any errors.           * Use the auto-parser and don't report any errors.
          */           */
   
         mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);          mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);
   
         memset(&key, 0, sizeof(DBT));          rec = 1;
         memset(&val, 0, sizeof(DBT));          hash = NULL;
         memset(&rkey, 0, sizeof(DBT));  
         memset(&rval, 0, sizeof(DBT));  
   
         val.size = sizeof(vbuf);          memset(&buf, 0, sizeof(struct buf));
         val.data = vbuf;          memset(&dbuf, 0, sizeof(struct buf));
         rkey.size = sizeof(recno_t);  
   
         rec = 1;          buf.size = dbuf.size = MANDOC_BUFSZ;
         ksz = rsz = 0;  
   
           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);
   
                   /* Initialise the in-memory hash of keywords. */
   
                   if (hash)
                           (*hash->close)(hash);
   
                   hash = dbopen(NULL, MANDOC_FLAGS, 0644, DB_HASH, NULL);
   
                   if (NULL == hash) {
                           perror("hash");
                           exit((int)MANDOCLEVEL_SYSERR);
                   }
   
                 /* Parse and get (non-empty) AST. */                  /* Parse and get (non-empty) AST. */
   
                 if (mparse_readfd(mp, -1, fn) >= MANDOCLEVEL_FATAL) {                  if (mparse_readfd(mp, -1, fn) >= MANDOCLEVEL_FATAL) {
                         fprintf(stderr, "%s: Parse failure\n", fn);                          fprintf(stderr, "%s: Parse failure\n", fn);
                         continue;                          continue;
                 }                  }
   
                 mparse_result(mp, &mdoc, &man);                  mparse_result(mp, &mdoc, &man);
   
                 if (NULL == mdoc && NULL == man)                  if (NULL == mdoc && NULL == man)
                         continue;                          continue;
   
                 /* Manual section: can be empty string. */  
   
                 msec = NULL != mdoc ?                  msec = NULL != mdoc ?
                         mdoc_meta(mdoc)->msec :                          mdoc_meta(mdoc)->msec :
                         man_meta(man)->msec;                          man_meta(man)->msec;
Line 367  main(int argc, char *argv[])
Line 391  main(int argc, char *argv[])
                         man_meta(man)->title;                          man_meta(man)->title;
                 arch = NULL != mdoc ? mdoc_meta(mdoc)->arch : NULL;                  arch = NULL != mdoc ? mdoc_meta(mdoc)->arch : NULL;
   
                 assert(msec);  
                 assert(mtitle);  
   
                 /*                  /*
                  * The index record value consists of a nil-terminated                   * The index record value consists of a nil-terminated
                  * filename, a nil-terminated manual section, and a                   * filename, a nil-terminated manual section, and a
Line 378  main(int argc, char *argv[])
Line 399  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. */
   
                 memset(val.data, 0, sizeof(uint32_t));  
                 memcpy(val.data + 4, &rec, sizeof(uint32_t));  
   
                 if (mdoc)                  if (mdoc)
                         pmdoc(db, fbbuf, &key, &ksz,                          pmdoc_node(hash, &buf, &dbuf,
                                 &val, &rval, &rsz, mdoc);                                  mdoc_node(mdoc), mdoc_meta(mdoc));
                 else                  else
                         pman(db, fbbuf, &key, &ksz,                          pman_node(hash, &buf, &dbuf, man_node(man));
                                 &val, &rval, &rsz, man);  
                   /*
                    * Copy from the in-memory hashtable of pending keywords
                    * into the database.
                    */
   
                   memset(vbuf, 0, sizeof(uint32_t));
                   memcpy(vbuf + 4, &rec, sizeof(uint32_t));
   
                   seq = R_FIRST;
                   while (0 == (ch = (*hash->seq)(hash, &key, &val, seq))) {
                           seq = R_NEXT;
   
                           memcpy(vbuf, val.data, sizeof(uint32_t));
                           val.size = sizeof(vbuf);
                           val.data = vbuf;
   
                           if (verb > 1)
                                   printf("%s: Keyword %s (%zu): 0x%x\n",
                                           fn, (char *)key.data, key.size,
                                           *(int *)val.data);
   
                           dbt_put(db, fbbuf, &key, &val);
   
                   }
   
                   if (ch < 0) {
                           perror("hash");
                           exit((int)MANDOCLEVEL_SYSERR);
                   }
   
                 /*                  /*
                  * Apply this to the index.  If we haven't had a                   * Apply to the index.  If we haven't had a description
                  * description 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;
   
                   if (verb > 0)
                           printf("%s: Indexed\n", fn);
   
                   dbt_put(idx, ibbuf, &key, &val);
                 rec++;                  rec++;
         }          }
   
         (*db->close)(db);          (*db->close)(db);
         (*idx->close)(idx);          (*idx->close)(idx);
   
           if (hash)
                   (*hash->close)(hash);
   
         mparse_free(mp);          mparse_free(mp);
   
         free(key.data);          free(buf.cp);
         free(rval.data);          free(dbuf.cp);
   
         /* Atomically replace the file with our temporary one. */          /* Atomically replace the file with our temporary one. */
   
Line 433  main(int argc, char *argv[])
Line 489  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)  buf_appendb(struct buf *buf, const void *cp, size_t sz)
 {  {
   
         if (0 == *ksz) {          /* Overshoot by MANDOC_BUFSZ. */
                 assert(0 == key->size);  
                 assert(NULL == key->data);          while (buf->len + sz >= buf->size) {
                 key->data = mandoc_malloc(MANDOC_BUFSZ);                  buf->size = buf->len + sz + MANDOC_BUFSZ;
                 *ksz = MANDOC_BUFSZ;                  buf->cp = mandoc_realloc(buf->cp, buf->size);
         }          }
   
         key->size = 0;          memcpy(buf->cp + (int)buf->len, cp, sz);
           buf->len += sz;
 }  }
   
 /*  /*
  * Append a binary value to a database entry.  This can be invoked   * Append a nil-terminated string to the buffer.
  * multiple times; the buffer is automatically resized.   * This can be invoked multiple times.
    * The buffer string will be nil-terminated.
    * If invoked multiple times, a space is put between strings.
  */   */
 static void  static void
 dbt_appendb(DBT *key, size_t *ksz, const void *cp, size_t sz)  buf_append(struct buf *buf, const char *cp)
 {  {
           size_t           sz;
   
         assert(key->data);          if (0 == (sz = strlen(cp)))
                   return;
   
         /* Overshoot by MANDOC_BUFSZ. */          if (buf->len)
                   buf->cp[(int)buf->len - 1] = ' ';
   
         while (key->size + sz >= *ksz) {          buf_appendb(buf, cp, sz + 1);
                 *ksz = key->size + sz + MANDOC_BUFSZ;  
                 key->data = mandoc_realloc(key->data, *ksz);  
         }  
   
         memcpy(key->data + (int)key->size, cp, sz);  
         key->size += sz;  
 }  }
   
 /*  /*
  * Append a nil-terminated string to the database entry.  This can be   * Recursively add all text from a given node.
  * invoked multiple times.  The database entry will be nil-terminated as   * This is optimised for general mdoc nodes in this context, which do
  * well; if invoked multiple times, a space is put between strings.   * not consist of subexpressions and having a recursive call for n->next
    * would be wasteful.
    * The "f" variable should be 0 unless called from pmdoc_Nd for the
    * description buffer, which does not start at the beginning of the
    * buffer.
  */   */
 static void  static void
 dbt_append(DBT *key, size_t *ksz, const char *cp)  buf_appendmdoc(struct buf *buf, const struct mdoc_node *n, int f)
 {  {
         size_t           sz;  
   
         if (0 == (sz = strlen(cp)))          for ( ; n; n = n->next) {
                 return;                  if (n->child)
                           buf_appendmdoc(buf, n->child, f);
   
         assert(key->data);                  if (MDOC_TEXT == n->type && f) {
                           f = 0;
                           buf_appendb(buf, n->string,
                                           strlen(n->string) + 1);
                   } else if (MDOC_TEXT == n->type)
                           buf_append(buf, n->string);
   
         if (key->size)          }
                 ((char *)key->data)[(int)key->size - 1] = ' ';  
   
         dbt_appendb(key, ksz, cp, sz + 1);  
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
 pmdoc_An(MDOC_ARGS)  pmdoc_An(MDOC_ARGS)
 {  {
         uint32_t         fl;  
   
         if (SEC_AUTHORS != n->sec)          if (SEC_AUTHORS != n->sec)
                 return;                  return;
   
         for (n = n->child; n; n = n->next)          buf_appendmdoc(buf, n->child, 0);
                 if (MDOC_TEXT == n->type)          hash_put(hash, buf, TYPE_AUTHOR);
                         dbt_append(key, ksz, n->string);  
   
         fl = (uint32_t)MANDOC_AUTHOR;  
         memcpy(val->data, &fl, 4);  
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
 pmdoc_Fd(MDOC_ARGS)  pmdoc_Fd(MDOC_ARGS)
 {  {
         uint32_t         fl;  
         const char      *start, *end;          const char      *start, *end;
         size_t           sz;          size_t           sz;
   
Line 550  pmdoc_Fd(MDOC_ARGS)
Line 604  pmdoc_Fd(MDOC_ARGS)
                 end--;                  end--;
   
         assert(end >= start);          assert(end >= start);
         dbt_appendb(key, ksz, start, (size_t)(end - start + 1));  
         dbt_appendb(key, ksz, "", 1);  
   
         fl = (uint32_t)MANDOC_INCLUDES;          buf_appendb(buf, start, (size_t)(end - start + 1));
         memcpy(val->data, &fl, 4);          buf_appendb(buf, "", 1);
   
           hash_put(hash, buf, TYPE_INCLUDES);
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
 pmdoc_Cd(MDOC_ARGS)  pmdoc_Cd(MDOC_ARGS)
 {  {
         uint32_t         fl;  
   
         if (SEC_SYNOPSIS != n->sec)          if (SEC_SYNOPSIS != n->sec)
                 return;                  return;
   
         for (n = n->child; n; n = n->next)          buf_appendmdoc(buf, n->child, 0);
                 if (MDOC_TEXT == n->type)          hash_put(hash, buf, TYPE_CONFIG);
                         dbt_append(key, ksz, n->string);  
   
         fl = (uint32_t)MANDOC_CONFIG;  
         memcpy(val->data, &fl, 4);  
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
 pmdoc_In(MDOC_ARGS)  pmdoc_In(MDOC_ARGS)
 {  {
         uint32_t         fl;  
   
         if (SEC_SYNOPSIS != n->sec)          if (SEC_SYNOPSIS != n->sec)
                 return;                  return;
         if (NULL == n->child || MDOC_TEXT != n->child->type)          if (NULL == n->child || MDOC_TEXT != n->child->type)
                 return;                  return;
   
         dbt_append(key, ksz, n->child->string);          buf_append(buf, n->child->string);
         fl = (uint32_t)MANDOC_INCLUDES;          hash_put(hash, buf, TYPE_INCLUDES);
         memcpy(val->data, &fl, 4);  
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
 pmdoc_Fn(MDOC_ARGS)  pmdoc_Fn(MDOC_ARGS)
 {  {
         uint32_t         fl;  
         const char      *cp;          const char      *cp;
   
         if (SEC_SYNOPSIS != n->sec)          if (SEC_SYNOPSIS != n->sec)
Line 613  pmdoc_Fn(MDOC_ARGS)
Line 659  pmdoc_Fn(MDOC_ARGS)
         while ('*' == *cp)          while ('*' == *cp)
                 cp++;                  cp++;
   
         dbt_append(key, ksz, cp);          buf_append(buf, cp);
         fl = (uint32_t)MANDOC_FUNCTION;          hash_put(hash, buf, TYPE_FUNCTION);
         memcpy(val->data, &fl, 4);  
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
 pmdoc_St(MDOC_ARGS)  pmdoc_St(MDOC_ARGS)
 {  {
         uint32_t         fl;  
   
         if (SEC_STANDARDS != n->sec)          if (SEC_STANDARDS != n->sec)
                 return;                  return;
         if (NULL == n->child || MDOC_TEXT != n->child->type)          if (NULL == n->child || MDOC_TEXT != n->child->type)
                 return;                  return;
   
         dbt_append(key, ksz, n->child->string);          buf_append(buf, n->child->string);
         fl = (uint32_t)MANDOC_STANDARD;          hash_put(hash, buf, TYPE_STANDARD);
         memcpy(val->data, &fl, 4);  
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
   pmdoc_Xr(MDOC_ARGS)
   {
   
           if (NULL == (n = n->child))
                   return;
   
           buf_appendb(buf, n->string, strlen(n->string));
   
           if (NULL != (n = n->next)) {
                   buf_appendb(buf, ".", 1);
                   buf_appendb(buf, n->string, strlen(n->string) + 1);
           } else
                   buf_appendb(buf, ".", 2);
   
           hash_put(hash, buf, TYPE_XREF);
   }
   
   /* ARGSUSED */
   static void
 pmdoc_Vt(MDOC_ARGS)  pmdoc_Vt(MDOC_ARGS)
 {  {
         uint32_t         fl;  
         const char      *start;          const char      *start;
         size_t           sz;          size_t           sz;
   
Line 667  pmdoc_Vt(MDOC_ARGS)
Line 728  pmdoc_Vt(MDOC_ARGS)
         if (0 == sz)          if (0 == sz)
                 return;                  return;
   
         dbt_appendb(key, ksz, start, sz);          buf_appendb(buf, start, sz);
         dbt_appendb(key, ksz, "", 1);          buf_appendb(buf, "", 1);
           hash_put(hash, buf, TYPE_VARIABLE);
         fl = (uint32_t)MANDOC_VARIABLE;  
         memcpy(val->data, &fl, 4);  
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
 pmdoc_Fo(MDOC_ARGS)  pmdoc_Fo(MDOC_ARGS)
 {  {
         uint32_t         fl;  
   
         if (SEC_SYNOPSIS != n->sec || MDOC_HEAD != n->type)          if (SEC_SYNOPSIS != n->sec || MDOC_HEAD != n->type)
                 return;                  return;
         if (NULL == n->child || MDOC_TEXT != n->child->type)          if (NULL == n->child || MDOC_TEXT != n->child->type)
                 return;                  return;
   
         dbt_append(key, ksz, n->child->string);          buf_append(buf, n->child->string);
         fl = (uint32_t)MANDOC_FUNCTION;          hash_put(hash, buf, TYPE_FUNCTION);
         memcpy(val->data, &fl, 4);  
 }  }
   
   
Line 695  pmdoc_Fo(MDOC_ARGS)
Line 752  pmdoc_Fo(MDOC_ARGS)
 static void  static void
 pmdoc_Nd(MDOC_ARGS)  pmdoc_Nd(MDOC_ARGS)
 {  {
         int              first;  
           if (MDOC_BODY != n->type)
                   return;
   
           buf_appendmdoc(dbuf, n->child, 1);
           buf_appendmdoc(buf, n->child, 0);
   
           hash_put(hash, buf, TYPE_DESC);
   }
   
   /* ARGSUSED */
   static void
   pmdoc_Pa(MDOC_ARGS)
   {
   
           if (SEC_FILES != n->sec)
                   return;
   
         for (first = 1, n = n->child; n; n = n->next) {          buf_appendmdoc(buf, n->child, 0);
                 if (MDOC_TEXT != n->type)          hash_put(hash, buf, TYPE_PATH);
                         continue;  
                 if (first)  
                         dbt_appendb(rval, rsz, n->string, strlen(n->string) + 1);  
                 else  
                         dbt_append(rval, rsz, n->string);  
                 first = 0;  
         }  
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
 pmdoc_Nm(MDOC_ARGS)  pmdoc_Nm(MDOC_ARGS)
 {  {
         uint32_t         fl;  
   
         if (SEC_NAME == n->sec) {          if (SEC_NAME == n->sec) {
                 for (n = n->child; n; n = n->next) {                  buf_appendmdoc(buf, n->child, 0);
                         if (MDOC_TEXT != n->type)                  hash_put(hash, buf, TYPE_NAME);
                                 continue;  
                         dbt_append(key, ksz, n->string);  
                 }  
                 fl = (uint32_t)MANDOC_NAME;  
                 memcpy(val->data, &fl, 4);  
                 return;                  return;
         } else if (SEC_SYNOPSIS != n->sec || MDOC_HEAD != n->type)          } else if (SEC_SYNOPSIS != n->sec || MDOC_HEAD != n->type)
                 return;                  return;
   
         for (n = n->child; n; n = n->next) {          if (NULL == n->child)
                 if (MDOC_TEXT != n->type)                  buf_append(buf, m->name);
                         continue;  
                 dbt_append(key, ksz, n->string);  
         }  
   
         fl = (uint32_t)MANDOC_UTILITY;          buf_appendmdoc(buf, n->child, 0);
         memcpy(val->data, &fl, 4);          hash_put(hash, buf, TYPE_UTILITY);
 }  }
   
 static void  static void
 dbt_put(DB *db, const char *dbn, DBT *key, DBT *val)  hash_put(DB *db, const struct buf *buf, int mask)
 {  {
           DBT              key, val;
           int              rc;
   
         if (0 == key->size)          if (buf->len < 2)
                 return;                  return;
   
         assert(key->data);          key.data = buf->cp;
           key.size = buf->len;
   
           if ((rc = (*db->get)(db, &key, &val, 0)) < 0) {
                   perror("hash");
                   exit((int)MANDOCLEVEL_SYSERR);
           } else if (0 == rc)
                   mask |= *(int *)val.data;
   
           val.data = &mask;
           val.size = sizeof(int);
   
           if ((rc = (*db->put)(db, &key, &val, 0)) < 0) {
                   perror("hash");
                   exit((int)MANDOCLEVEL_SYSERR);
           }
   }
   
   static void
   dbt_put(DB *db, const char *dbn, DBT *key, DBT *val)
   {
   
           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 779  pmdoc_node(MDOC_ARGS)
Line 859  pmdoc_node(MDOC_ARGS)
                 if (NULL == mdocs[n->tok])                  if (NULL == mdocs[n->tok])
                         break;                          break;
   
                 dbt_init(key, ksz);                  buf->len = 0;
                   (*mdocs[n->tok])(hash, buf, dbuf, n, m);
                 (*mdocs[n->tok])(db, dbn, key, ksz, val, rval, rsz, n);  
                 dbt_put(db, dbn, key, val);  
                 break;                  break;
         default:          default:
                 break;                  break;
         }          }
   
         pmdoc_node(db, dbn, key, ksz, val, rval, rsz, n->child);          pmdoc_node(hash, buf, dbuf, n->child, m);
         pmdoc_node(db, dbn, key, ksz, val, rval, rsz, n->next);          pmdoc_node(hash, buf, dbuf, n->next, m);
 }  }
   
 static int  static int
Line 798  pman_node(MAN_ARGS)
Line 876  pman_node(MAN_ARGS)
         const struct man_node *head, *body;          const struct man_node *head, *body;
         const char      *start, *sv;          const char      *start, *sv;
         size_t           sz;          size_t           sz;
         uint32_t         fl;  
   
         if (NULL == n)          if (NULL == n)
                 return(0);                  return(0);
Line 821  pman_node(MAN_ARGS)
Line 898  pman_node(MAN_ARGS)
                                 NULL != (body = body->child) &&                                  NULL != (body = body->child) &&
                                 MAN_TEXT == body->type) {                                  MAN_TEXT == body->type) {
   
                         fl = (uint32_t)MANDOC_NAME;  
                         memcpy(val->data, &fl, 4);  
   
                         assert(body->string);                          assert(body->string);
                         start = sv = body->string;                          start = sv = body->string;
   
Line 842  pman_node(MAN_ARGS)
Line 916  pman_node(MAN_ARGS)
                                 if ('\0' == start[(int)sz])                                  if ('\0' == start[(int)sz])
                                         break;                                          break;
   
                                 dbt_init(key, ksz);                                  buf->len = 0;
                                 dbt_appendb(key, ksz, start, sz);                                  buf_appendb(buf, start, sz);
                                 dbt_appendb(key, ksz, "", 1);                                  buf_appendb(buf, "", 1);
   
                                 dbt_put(db, dbn, key, val);                                  hash_put(hash, buf, TYPE_NAME);
   
                                 if (' ' == start[(int)sz]) {                                  if (' ' == start[(int)sz]) {
                                         start += (int)sz + 1;                                          start += (int)sz + 1;
Line 860  pman_node(MAN_ARGS)
Line 934  pman_node(MAN_ARGS)
                         }                          }
   
                         if (sv == start) {                          if (sv == start) {
                                 dbt_init(key, ksz);                                  buf->len = 0;
                                 dbt_append(key, ksz, start);                                  buf_append(buf, start);
                                 return(1);                                  return(1);
                         }                          }
   
Line 880  pman_node(MAN_ARGS)
Line 954  pman_node(MAN_ARGS)
                         while (' ' == *start)                          while (' ' == *start)
                                 start++;                                  start++;
   
                         dbt_appendb(rval, rsz, start, strlen(start) + 1);                          sz = strlen(start) + 1;
                           buf_appendb(dbuf, start, sz);
                           buf_appendb(buf, start, sz);
                 }                  }
         }          }
   
         if (pman_node(db, dbn, key, ksz, val, rval, rsz, n->child))          if (pman_node(hash, buf, dbuf, n->child))
                 return(1);                  return(1);
         if (pman_node(db, dbn, key, ksz, val, rval, rsz, n->next))          if (pman_node(hash, buf, dbuf, n->next))
                 return(1);                  return(1);
   
         return(0);          return(0);
 }  }
   
 static void  static void
 pman(DB *db, const char *dbn, DBT *key, size_t *ksz,  
                 DBT *val, DBT *rval, size_t *rsz, struct man *m)  
 {  
   
         pman_node(db, dbn, key, ksz, val, rval, rsz, man_node(m));  
 }  
   
   
 static void  
 pmdoc(DB *db, const char *dbn, DBT *key, size_t *ksz,  
                 DBT *val, DBT *rval, size_t *rsz, struct mdoc *m)  
 {  
   
         pmdoc_node(db, dbn, key, ksz, val, rval, rsz, mdoc_node(m));  
 }  
   
 static void  
 usage(void)  usage(void)
 {  {
   
         fprintf(stderr, "usage: %s "          fprintf(stderr, "usage: %s [-v] [-d path] [file...]\n",
                         "[-d path] "  
                         "[file...]\n",  
                         progname);                          progname);
 }  }
Legend:
Removed from v.1.2  
changed lines
  Added in v.1.14
CVSweb