[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.3 and 1.6

version 1.3, 2011/04/03 14:18:29 version 1.6, 2011/04/05 13:09:33
Line 51  enum type {
Line 51  enum type {
         MANDOC_VARIABLE          MANDOC_VARIABLE
 };  };
   
   #define MAN_ARGS          DB *db, \
                             const char *dbn, \
                             DBT *key, size_t *ksz, \
                             DBT *val, \
                             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, \
Line 61  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              version(void);  
 static  void              usage(void);  static  void              usage(void);
   static  void              pman(DB *, const char *,
                                   DBT *, size_t *, DBT *,
                                   const char *, struct man *);
   static  int               pman_node(MAN_ARGS);
 static  void              pmdoc(DB *, const char *,  static  void              pmdoc(DB *, const char *,
                                 DBT *, size_t *, DBT *,                                  DBT *, size_t *, DBT *,
                                 const char *, struct mdoc *);                                  const char *, struct mdoc *);
Line 208  main(int argc, char *argv[])
Line 216  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 */
         char            *fn;          char            *fn;
         const char      *dir; /* result dir (default: cwd) */          const char      *dir; /* result dir (default: cwd) */
         char             ibuf[MAXPATHLEN], /* index fname */          char             ibuf[MAXPATHLEN], /* index fname */
Line 234  main(int argc, char *argv[])
Line 243  main(int argc, char *argv[])
   
         dir = "";          dir = "";
   
         while (-1 != (c = getopt(argc, argv, "d:V")))          while (-1 != (c = getopt(argc, argv, "d:")))
                 switch (c) {                  switch (c) {
                 case ('d'):                  case ('d'):
                         dir = optarg;                          dir = optarg;
                         break;                          break;
                 case ('V'):  
                         version();  
                         return((int)MANDOCLEVEL_OK);  
                 default:                  default:
                         usage();                          usage();
                         return((int)MANDOCLEVEL_BADARG);                          return((int)MANDOCLEVEL_BADARG);
Line 329  main(int argc, char *argv[])
Line 335  main(int argc, char *argv[])
         while (NULL != (fn = *argv++)) {          while (NULL != (fn = *argv++)) {
                 mparse_reset(mp);                  mparse_reset(mp);
   
                 if (mparse_readfd(mp, -1, fn) >= MANDOCLEVEL_FATAL)                  if (mparse_readfd(mp, -1, fn) >= MANDOCLEVEL_FATAL) {
                           fprintf(stderr, "%s: Parse failure\n", fn);
                         continue;                          continue;
                   }
   
                 mparse_result(mp, &mdoc, NULL);                  mparse_result(mp, &mdoc, &man);
                 if (NULL == mdoc)                  if (NULL == mdoc && NULL == man)
                         continue;                          continue;
   
                 rkey.data = &rec;                  rkey.data = &rec;
Line 348  main(int argc, char *argv[])
Line 356  main(int argc, char *argv[])
                 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));
   
                 pmdoc(db, fbbuf, &key, &ksz, &val, fn, mdoc);                  if (mdoc)
                           pmdoc(db, fbbuf, &key, &ksz, &val, fn, mdoc);
                   else
                           pman(db, fbbuf, &key, &ksz, &val, fn, man);
                 rec++;                  rec++;
         }          }
   
Line 443  pmdoc_Fd(MDOC_ARGS)
Line 454  pmdoc_Fd(MDOC_ARGS)
                 return;                  return;
         if (NULL == (n = n->child) || MDOC_TEXT != n->type)          if (NULL == (n = n->child) || MDOC_TEXT != n->type)
                 return;                  return;
   
           /*
            * Only consider those `Fd' macro fields that begin with an
            * "inclusion" token (versus, e.g., #define).
            */
         if (strcmp("#include", n->string))          if (strcmp("#include", n->string))
                 return;                  return;
   
         if (NULL == (n = n->next) || MDOC_TEXT != n->type)          if (NULL == (n = n->next) || MDOC_TEXT != n->type)
                 return;                  return;
   
           /*
            * Strip away the enclosing angle brackets and make sure we're
            * not zero-length.
            */
   
         start = n->string;          start = n->string;
         if ('<' == *start)          if ('<' == *start || '"' == *start)
                 start++;                  start++;
   
         if (0 == (sz = strlen(start)))          if (0 == (sz = strlen(start)))
                 return;                  return;
   
         end = &start[(int)sz - 1];          end = &start[(int)sz - 1];
         if ('>' == *end)          if ('>' == *end || '"' == *end)
                 end--;                  end--;
   
         nil = '\0';          nil = '\0';
Line 501  pmdoc_Fn(MDOC_ARGS)
Line 523  pmdoc_Fn(MDOC_ARGS)
         if (NULL == cp)          if (NULL == cp)
                 cp = n->child->string;                  cp = n->child->string;
   
         /* Ignore pointers. */          /* Strip away pointer symbol. */
   
         while ('*' == *cp)          while ('*' == *cp)
                 cp++;                  cp++;
Line 528  pmdoc_Vt(MDOC_ARGS)
Line 550  pmdoc_Vt(MDOC_ARGS)
                 return;                  return;
   
         /*          /*
          * Strip away leading '*' and trailing ';'.           * Strip away leading pointer symbol '*' and trailing ';'.
          */           */
   
         start = n->last->string;          start = n->last->string;
Line 640  pmdoc_node(MDOC_ARGS)
Line 662  pmdoc_node(MDOC_ARGS)
         pmdoc_node(db, dbn, key, ksz, val, n->next);          pmdoc_node(db, dbn, key, ksz, val, n->next);
 }  }
   
   static int
   pman_node(MAN_ARGS)
   {
           const struct man_node *head, *body;
           const char      *end, *start;
           char             nil;
           uint32_t         fl;
   
           if (NULL == n)
                   return(0);
   
           /*
            * We're only searching for one thing: the first text child in
            * the BODY of a NAME section.  Since we don't keep track of
            * sections in -man, run some hoops to find out whether we're in
            * the correct section or not.
            */
   
           if (MAN_BODY == n->type && MAN_SH == n->tok) {
                   body = n;
                   assert(body->parent);
                   if (NULL != (head = body->parent->head) &&
                                   1 == head->nchild &&
                                   NULL != (head = (head->child)) &&
                                   MAN_TEXT == head->type &&
                                   0 == strcmp(head->string, "NAME") &&
                                   NULL != (body = body->child) &&
                                   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;
                           memcpy(val->data, &fl, 4);
                           return(1);
                   }
           }
   
           if (pman_node(db, dbn, key, ksz, val, n->child))
                   return(1);
           if (pman_node(db, dbn, key, ksz, val, n->next))
                   return(1);
   
           return(0);
   }
   
 static void  static void
 pmdoc(DB *db, const char *dbn,  pman(DB *db, const char *dbn,
                 DBT *key, size_t *ksz, DBT *val,                  DBT *key, size_t *ksz, DBT *val,
                 const char *path, struct mdoc *m)                  const char *path, struct man *m)
 {  {
   
         pmdoc_node(db, dbn, key, ksz, val, mdoc_node(m));          pman_node(db, dbn, key, ksz, val, man_node(m));
 }  }
   
   
 static void  static void
 version(void)  pmdoc(DB *db, const char *dbn,
                   DBT *key, size_t *ksz, DBT *val,
                   const char *path, struct mdoc *m)
 {  {
   
         printf("%s %s\n", progname, VERSION);          pmdoc_node(db, dbn, key, ksz, val, mdoc_node(m));
 }  }
   
 static void  static void
Line 661  usage(void)
Line 737  usage(void)
 {  {
   
         fprintf(stderr, "usage: %s "          fprintf(stderr, "usage: %s "
                         "[-V] "  
                         "[-d path] "                          "[-d path] "
                         "[file...]\n",                          "[file...]\n",
                         progname);                          progname);
Legend:
Removed from v.1.3  
changed lines
  Added in v.1.6
CVSweb