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

version 1.6, 2011/04/05 13:09:33 version 1.10, 2011/04/11 21:36:44
Line 66  static void    dbt_append(DBT *, size_t *, const char 
Line 66  static void    dbt_append(DBT *, size_t *, const char 
 static  void              dbt_appendb(DBT *, size_t *,  static  void              dbt_appendb(DBT *, size_t *,
                                 const void *, size_t);                                  const void *, 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              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 218  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 303  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 330  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 344  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 448  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 481  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 540  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;
         if (MDOC_Vt == n->tok && MDOC_BODY != n->type)          if (MDOC_Vt == n->tok && MDOC_BODY != n->type)
                 return;                  return;
         if (NULL == n->child || MDOC_TEXT != n->child->type)          if (NULL == n->last || MDOC_TEXT != n->last->type)
                 return;                  return;
   
         /*          /*
Line 568  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 619  pmdoc_Nm(MDOC_ARGS)
Line 621  pmdoc_Nm(MDOC_ARGS)
         memcpy(val->data, &fl, 4);          memcpy(val->data, &fl, 4);
 }  }
   
   static void
   dbt_put(DB *db, const char *dbn, DBT *key, DBT *val)
   {
   
           if (0 == key->size)
                   return;
   
           assert(key->data);
           assert(val->size);
           assert(val->data);
   
           if (0 == (*db->put)(db, key, val, 0))
                   return;
   
           perror(dbn);
           exit((int)MANDOCLEVEL_SYSERR);
           /* NOTREACHED */
   }
   
 /*  /*
  * Call out to per-macro handlers after clearing the persistent database   * Call out to per-macro handlers after clearing the persistent database
  * key.  If the macro sets the database key, flush it to the database.   * key.  If the macro sets the database key, flush it to the database.
Line 646  pmdoc_node(MDOC_ARGS)
Line 667  pmdoc_node(MDOC_ARGS)
                 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, n);
   
                 if (0 == key->size)                  dbt_put(db, dbn, key, val);
                         break;                  break;
                 if (0 == (*db->put)(db, key, val, 0))  
                         break;  
   
                 perror(dbn);  
                 exit((int)MANDOCLEVEL_SYSERR);  
                 /* NOTREACHED */  
         default:          default:
                 break;                  break;
         }          }
Line 666  static int
Line 681  static int
 pman_node(MAN_ARGS)  pman_node(MAN_ARGS)
 {  {
         const struct man_node *head, *body;          const struct man_node *head, *body;
         const char      *end, *start;          const char      *start;
         char             nil;          const char       nil = '\0';
           size_t           sz;
         uint32_t         fl;          uint32_t         fl;
   
         if (NULL == n)          if (NULL == n)
Line 690  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';  
   
                         start = body->string;  
                         if (NULL == (end = strchr(start, ' ')))  
                                 end = start + strlen(start);  
   
                         dbt_init(key, ksz);  
                         dbt_appendb(key, ksz, start, end - start + 1);  
                         dbt_appendb(key, ksz, &nil, 1);  
                         fl = MANDOC_NAME;                          fl = MANDOC_NAME;
                         memcpy(val->data, &fl, 4);                          memcpy(val->data, &fl, 4);
   
                           start = body->string;
   
                           /*
                            * Go through a special heuristic dance here.
                            * This is why -man manuals are great!
                            * Conventionally, one or more manual names are
                            * comma-specified prior to a whitespace, then a
                            * dash, then a description.  Try to puzzle out
                            * the name parts here.
                            */
   
                           while (start) {
                                   sz = strcspn(start, " ,");
                                   if ('\0' == start[(int)sz])
                                           break;
   
                                   dbt_init(key, ksz);
                                   dbt_appendb(key, ksz, start, sz);
                                   dbt_appendb(key, ksz, &nil, 1);
   
                                   dbt_put(db, dbn, key, val);
   
                                   if (' ' == start[(int)sz])
                                           break;
   
                                   assert(',' == start[(int)sz]);
                                   start += (int)sz + 1;
                                   while (' ' == *start)
                                           start++;
                           }
   
                         return(1);                          return(1);
                 }                  }
         }          }
Line 714  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 724  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.6  
changed lines
  Added in v.1.10
CVSweb