[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.8 and 1.10

version 1.8, 2011/04/05 14:10:52 version 1.10, 2011/04/11 21:36:44
Line 68  static void    dbt_appendb(DBT *, size_t *, 
Line 68  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 *,  static  void              pman(DB *, const char *, DBT *,
                                 DBT *, size_t *, DBT *,                                  size_t *, DBT *, struct man *);
                                 const char *, struct man *);  
 static  int               pman_node(MAN_ARGS);  static  int               pman_node(MAN_ARGS);
 static  void              pmdoc(DB *, const char *,  static  void              pmdoc(DB *, const char *, DBT *,
                                 DBT *, size_t *, DBT *,                                  size_t *, DBT *, 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);
 static  void              pmdoc_In(MDOC_ARGS);  static  void              pmdoc_In(MDOC_ARGS);
Line 219  main(int argc, char *argv[])
Line 217  main(int argc, char *argv[])
         struct mdoc     *mdoc; /* resulting mdoc */          struct mdoc     *mdoc; /* resulting mdoc */
         struct man      *man; /* resulting man */          struct man      *man; /* resulting man */
         char            *fn;          char            *fn;
         const char      *dir; /* result dir (default: cwd) */          const char      *msec,
                           *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              c;
         DB              *index, /* 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; /* entry buffer size */          size_t           ksz, rsz; /* entry buffer size */
         char             vbuf[8];          char             vbuf[8];
         BTREEINFO        info; /* btree configuration */          BTREEINFO        info; /* btree configuration */
         recno_t          rec;          recno_t          rec;
Line 304  main(int argc, char *argv[])
Line 303  main(int argc, char *argv[])
                 exit((int)MANDOCLEVEL_SYSERR);                  exit((int)MANDOCLEVEL_SYSERR);
         }          }
   
         index = dbopen(ibbuf, MANDOC_FLAGS, 0644, DB_RECNO, NULL);          idx = dbopen(ibbuf, MANDOC_FLAGS, 0644, DB_RECNO, NULL);
   
         if (NULL == db) {          if (NULL == db) {
                 perror(ibbuf);                  perror(ibbuf);
Line 331  main(int argc, char *argv[])
Line 330  main(int argc, char *argv[])
         rkey.size = sizeof(recno_t);          rkey.size = sizeof(recno_t);
   
         rec = 1;          rec = 1;
         ksz = 0;          ksz = rsz = 0;
   
         while (NULL != (fn = *argv++)) {          while (NULL != (fn = *argv++)) {
                 mparse_reset(mp);                  mparse_reset(mp);
Line 345  main(int argc, char *argv[])
Line 344  main(int argc, char *argv[])
                 if (NULL == mdoc && NULL == man)                  if (NULL == mdoc && NULL == man)
                         continue;                          continue;
   
                   msec = NULL != mdoc ?
                           mdoc_meta(mdoc)->msec :
                           man_meta(man)->msec;
   
                 rkey.data = &rec;                  rkey.data = &rec;
                 rval.data = fn;  
                 rval.size = strlen(fn) + 1;  
   
                 if (-1 == (*index->put)(index, &rkey, &rval, 0)) {                  dbt_init(&rval, &rsz);
                         perror(ibbuf);                  dbt_appendb(&rval, &rsz, fn, strlen(fn) + 1);
                         break;                  dbt_appendb(&rval, &rsz, msec, strlen(msec) + 1);
                 }  
   
                   dbt_put(idx, ibbuf, &rkey, &rval);
   
                 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, fn, mdoc);                          pmdoc(db, fbbuf, &key, &ksz, &val, mdoc);
                 else                  else
                         pman(db, fbbuf, &key, &ksz, &val, fn, man);                          pman(db, fbbuf, &key, &ksz, &val, man);
                 rec++;                  rec++;
         }          }
   
         (*db->close)(db);          (*db->close)(db);
         (*index->close)(index);          (*idx->close)(idx);
   
         mparse_free(mp);          mparse_free(mp);
   
         free(key.data);          free(key.data);
           free(rval.data);
   
         /* Atomically replace the file with our temporary one. */          /* Atomically replace the file with our temporary one. */
   
Line 449  pmdoc_Fd(MDOC_ARGS)
Line 452  pmdoc_Fd(MDOC_ARGS)
         uint32_t         fl;          uint32_t         fl;
         const char      *start, *end;          const char      *start, *end;
         size_t           sz;          size_t           sz;
         char             nil;          const char       nil = '\0';
   
         if (SEC_SYNOPSIS != n->sec)          if (SEC_SYNOPSIS != n->sec)
                 return;                  return;
Line 482  pmdoc_Fd(MDOC_ARGS)
Line 485  pmdoc_Fd(MDOC_ARGS)
         if ('>' == *end || '"' == *end)          if ('>' == *end || '"' == *end)
                 end--;                  end--;
   
         nil = '\0';  
         dbt_appendb(key, ksz, start, end - start + 1);          dbt_appendb(key, ksz, start, end - start + 1);
         dbt_appendb(key, ksz, &nil, 1);          dbt_appendb(key, ksz, &nil, 1);
   
Line 541  pmdoc_Vt(MDOC_ARGS)
Line 543  pmdoc_Vt(MDOC_ARGS)
         uint32_t         fl;          uint32_t         fl;
         const char      *start, *end;          const char      *start, *end;
         size_t           sz;          size_t           sz;
         char             nil;          const char       nil = '\0';
   
         if (SEC_SYNOPSIS != n->sec)          if (SEC_SYNOPSIS != n->sec)
                 return;                  return;
Line 569  pmdoc_Vt(MDOC_ARGS)
Line 571  pmdoc_Vt(MDOC_ARGS)
         if (end == start)          if (end == start)
                 return;                  return;
   
         nil = '\0';  
         dbt_appendb(key, ksz, start, end - start + 1);          dbt_appendb(key, ksz, start, end - start + 1);
         dbt_appendb(key, ksz, &nil, 1);          dbt_appendb(key, ksz, &nil, 1);
         fl = MANDOC_VARIABLE;          fl = MANDOC_VARIABLE;
Line 628  dbt_put(DB *db, const char *dbn, DBT *key, DBT *val)
Line 629  dbt_put(DB *db, const char *dbn, DBT *key, DBT *val)
                 return;                  return;
   
         assert(key->data);          assert(key->data);
         assert(8 == val->size);          assert(val->size);
         assert(val->data);          assert(val->data);
   
         if (0 == (*db->put)(db, key, val, 0))          if (0 == (*db->put)(db, key, val, 0))
Line 681  pman_node(MAN_ARGS)
Line 682  pman_node(MAN_ARGS)
 {  {
         const struct man_node *head, *body;          const struct man_node *head, *body;
         const char      *start;          const char      *start;
         char             nil;          const char       nil = '\0';
         size_t           sz;          size_t           sz;
         uint32_t         fl;          uint32_t         fl;
   
Line 705  pman_node(MAN_ARGS)
Line 706  pman_node(MAN_ARGS)
                                 0 == strcmp(head->string, "NAME") &&                                  0 == strcmp(head->string, "NAME") &&
                                 NULL != (body = body->child) &&                                  NULL != (body = body->child) &&
                                 MAN_TEXT == body->type) {                                  MAN_TEXT == body->type) {
                         nil = '\0';  
   
                         fl = MANDOC_NAME;                          fl = MANDOC_NAME;
                         memcpy(val->data, &fl, 4);                          memcpy(val->data, &fl, 4);
Line 754  pman_node(MAN_ARGS)
Line 754  pman_node(MAN_ARGS)
 }  }
   
 static void  static void
 pman(DB *db, const char *dbn,  pman(DB *db, const char *dbn, DBT *key,
                 DBT *key, size_t *ksz, DBT *val,                  size_t *ksz, DBT *val, struct man *m)
                 const char *path, struct man *m)  
 {  {
   
         pman_node(db, dbn, key, ksz, val, man_node(m));          pman_node(db, dbn, key, ksz, val, man_node(m));
Line 764  pman(DB *db, const char *dbn, 
Line 763  pman(DB *db, const char *dbn, 
   
   
 static void  static void
 pmdoc(DB *db, const char *dbn,  pmdoc(DB *db, const char *dbn, DBT *key,
                 DBT *key, size_t *ksz, DBT *val,                  size_t *ksz, DBT *val, struct mdoc *m)
                 const char *path, struct mdoc *m)  
 {  {
   
         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.8  
changed lines
  Added in v.1.10
CVSweb