[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.10 and 1.11

version 1.10, 2011/04/11 21:36:44 version 1.11, 2011/04/11 22:56:25
Line 55  enum type {
Line 55  enum type {
                           const char *dbn, \                            const char *dbn, \
                           DBT *key, size_t *ksz, \                            DBT *key, size_t *ksz, \
                           DBT *val, \                            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 *db, \
                           const char *dbn, \                            const char *dbn, \
                           DBT *key, size_t *ksz, \                            DBT *key, size_t *ksz, \
                           DBT *val, \                            DBT *val, \
                             DBT *rval, size_t *rsz, \
                           const struct mdoc_node *n                            const struct mdoc_node *n
   
 static  void              dbt_append(DBT *, size_t *, const char *);  static  void              dbt_append(DBT *, size_t *, const char *);
Line 68  static void    dbt_appendb(DBT *, size_t *, 
Line 70  static void    dbt_appendb(DBT *, size_t *, 
 static  void              dbt_init(DBT *, 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              usage(void);
 static  void              pman(DB *, const char *, DBT *,  static  void              pman(DB *, const char *, DBT *, size_t *,
                                 size_t *, DBT *, struct man *);                                  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 *,  static  void              pmdoc(DB *, const char *, DBT *, size_t *,
                                 size_t *, DBT *, struct mdoc *);                                  DBT *, DBT *, size_t *, 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);
 static  void              pmdoc_In(MDOC_ARGS);  static  void              pmdoc_In(MDOC_ARGS);
 static  void              pmdoc_Fn(MDOC_ARGS);  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_Nm(MDOC_ARGS);  static  void              pmdoc_Nm(MDOC_ARGS);
 static  void              pmdoc_Vt(MDOC_ARGS);  static  void              pmdoc_Vt(MDOC_ARGS);
   
Line 117  static const pmdoc_nf   mdocs[MDOC_MAX] = {
Line 120  static const pmdoc_nf   mdocs[MDOC_MAX] = {
         NULL, /* Ic */          NULL, /* Ic */
         pmdoc_In, /* In */          pmdoc_In, /* In */
         NULL, /* Li */          NULL, /* Li */
         NULL, /* Nd */          pmdoc_Nd, /* Nd */
         pmdoc_Nm, /* Nm */          pmdoc_Nm, /* Nm */
         NULL, /* Op */          NULL, /* Op */
         NULL, /* Ot */          NULL, /* Ot */
Line 216  main(int argc, char *argv[])
Line 219  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 */
         struct man      *man; /* resulting man */          struct man      *man; /* resulting man */
         char            *fn;          char            *fn; /* current file being parsed */
         const char      *msec,          const char      *msec, /* manual section */
                         *dir; /* result dir (default: cwd) */                          *dir; /* result dir (default: cwd) */
         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              c;          int              ch;
         DB              *idx, /* index database */          DB              *idx, /* index database */
                         *db; /* keyword database */                          *db; /* keyword database */
         DBT              rkey, rval, /* recno entries */          DBT              rkey, rval, /* recno entries */
                          key, val; /* persistent keyword entries */                           key, val; /* persistent keyword entries */
         size_t           ksz, rsz; /* entry buffer size */          size_t           sv,
         char             vbuf[8];                           ksz, rsz; /* entry buffer size */
           char             vbuf[8]; /* stringified record number */
         BTREEINFO        info; /* btree configuration */          BTREEINFO        info; /* btree configuration */
         recno_t          rec;          recno_t          rec; /* current record number */
         extern int       optind;          extern int       optind;
         extern char     *optarg;          extern char     *optarg;
   
Line 243  main(int argc, char *argv[])
Line 247  main(int argc, char *argv[])
   
         dir = "";          dir = "";
   
         while (-1 != (c = getopt(argc, argv, "d:")))          while (-1 != (ch = getopt(argc, argv, "d:")))
                 switch (c) {                  switch (ch) {
                 case ('d'):                  case ('d'):
                         dir = optarg;                          dir = optarg;
                         break;                          break;
Line 335  main(int argc, char *argv[])
Line 339  main(int argc, char *argv[])
         while (NULL != (fn = *argv++)) {          while (NULL != (fn = *argv++)) {
                 mparse_reset(mp);                  mparse_reset(mp);
   
                   /* 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;
   
                 rkey.data = &rec;                  assert(msec);
   
                   /*
                    * The index record value consists of a nil-terminated
                    * filename, a nil-terminated manual section, and a
                    * nil-terminated description.  Since the description
                    * may not be set, we set a sentinel to see if we're
                    * going to write a nil byte in its place.
                    */
   
                 dbt_init(&rval, &rsz);                  dbt_init(&rval, &rsz);
                 dbt_appendb(&rval, &rsz, fn, strlen(fn) + 1);                  dbt_appendb(&rval, &rsz, fn, strlen(fn) + 1);
                 dbt_appendb(&rval, &rsz, msec, strlen(msec) + 1);                  dbt_appendb(&rval, &rsz, msec, strlen(msec) + 1);
                   sv = rval.size;
   
                 dbt_put(idx, ibbuf, &rkey, &rval);                  /* Fix the record number in the btree value. */
   
                 memset(val.data, 0, sizeof(uint32_t));                  memset(val.data, 0, sizeof(uint32_t));
                 memcpy(val.data + 4, &rec, sizeof(uint32_t));                  memcpy(val.data + 4, &rec, sizeof(uint32_t));
   
                 if (mdoc)                  if (mdoc)
                         pmdoc(db, fbbuf, &key, &ksz, &val, mdoc);                          pmdoc(db, fbbuf, &key, &ksz,
                                   &val, &rval, &rsz, mdoc);
                 else                  else
                         pman(db, fbbuf, &key, &ksz, &val, man);                          pman(db, fbbuf, &key, &ksz,
                                   &val, &rval, &rsz, man);
   
                   /*
                    * Apply this to the index.  If we haven't had a
                    * description set, put an empty one in now.
                    */
   
                   if (rval.size == sv)
                           dbt_appendb(&rval, &rsz, "", 1);
   
                   rkey.data = &rec;
                   dbt_put(idx, ibbuf, &rkey, &rval);
   
                   printf("Indexed: %s\n", fn);
                 rec++;                  rec++;
         }          }
   
Line 593  pmdoc_Fo(MDOC_ARGS)
Line 624  pmdoc_Fo(MDOC_ARGS)
         memcpy(val->data, &fl, 4);          memcpy(val->data, &fl, 4);
 }  }
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
   pmdoc_Nd(MDOC_ARGS)
   {
           int              first;
   
           for (first = 1, n = n->child; n; n = n->next) {
                   if (MDOC_TEXT != n->type)
                           continue;
                   if (first)
                           dbt_appendb(rval, rsz, n->string, strlen(n->string) + 1);
                   else
                           dbt_append(rval, rsz, n->string);
   
                   first = 0;
           }
   }
   
   /* ARGSUSED */
   static void
 pmdoc_Nm(MDOC_ARGS)  pmdoc_Nm(MDOC_ARGS)
 {  {
         uint32_t         fl;          uint32_t         fl;
Line 665  pmdoc_node(MDOC_ARGS)
Line 715  pmdoc_node(MDOC_ARGS)
                         break;                          break;
   
                 dbt_init(key, ksz);                  dbt_init(key, ksz);
                 (*mdocs[n->tok])(db, dbn, key, ksz, val, n);                  (*mdocs[n->tok])(db, dbn, key, ksz, val, rval, rsz, n);
   
                 dbt_put(db, dbn, key, val);                  dbt_put(db, dbn, key, val);
                 break;                  break;
Line 673  pmdoc_node(MDOC_ARGS)
Line 723  pmdoc_node(MDOC_ARGS)
                 break;                  break;
         }          }
   
         pmdoc_node(db, dbn, key, ksz, val, n->child);          pmdoc_node(db, dbn, key, ksz, val, rval, rsz, n->child);
         pmdoc_node(db, dbn, key, ksz, val, n->next);          pmdoc_node(db, dbn, key, ksz, val, rval, rsz, n->next);
 }  }
   
 static int  static int
Line 745  pman_node(MAN_ARGS)
Line 795  pman_node(MAN_ARGS)
                 }                  }
         }          }
   
         if (pman_node(db, dbn, key, ksz, val, n->child))          if (pman_node(db, dbn, key, ksz, val, rval, rsz, n->child))
                 return(1);                  return(1);
         if (pman_node(db, dbn, key, ksz, val, n->next))          if (pman_node(db, dbn, key, ksz, val, rval, rsz, n->next))
                 return(1);                  return(1);
   
         return(0);          return(0);
 }  }
   
 static void  static void
 pman(DB *db, const char *dbn, DBT *key,  pman(DB *db, const char *dbn, DBT *key, size_t *ksz,
                 size_t *ksz, DBT *val, struct man *m)                  DBT *val, DBT *rval, size_t *rsz, struct man *m)
 {  {
   
         pman_node(db, dbn, key, ksz, val, man_node(m));          pman_node(db, dbn, key, ksz, val, rval, rsz, man_node(m));
 }  }
   
   
 static void  static void
 pmdoc(DB *db, const char *dbn, DBT *key,  pmdoc(DB *db, const char *dbn, DBT *key, size_t *ksz,
                 size_t *ksz, DBT *val, struct mdoc *m)                  DBT *val, DBT *rval, size_t *rsz, struct mdoc *m)
 {  {
   
         pmdoc_node(db, dbn, key, ksz, val, mdoc_node(m));          pmdoc_node(db, dbn, key, ksz, val, rval, rsz, mdoc_node(m));
 }  }
   
 static void  static void
Legend:
Removed from v.1.10  
changed lines
  Added in v.1.11
CVSweb