[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.11 and 1.20

version 1.11, 2011/04/11 22:56:25 version 1.20, 2011/05/12 01:45:55
Line 48  enum type {
Line 48  enum type {
         MANDOC_FUNCTION,          MANDOC_FUNCTION,
         MANDOC_UTILITY,          MANDOC_UTILITY,
         MANDOC_INCLUDES,          MANDOC_INCLUDES,
         MANDOC_VARIABLE          MANDOC_VARIABLE,
           MANDOC_STANDARD,
           MANDOC_AUTHOR,
           MANDOC_CONFIG
 };  };
   
 #define MAN_ARGS          DB *db, \  #define MAN_ARGS          DB *db, \
Line 76  static int    pman_node(MAN_ARGS);
Line 79  static int    pman_node(MAN_ARGS);
 static  void              pmdoc(DB *, const char *, DBT *, size_t *,  static  void              pmdoc(DB *, const char *, DBT *, size_t *,
                                 DBT *, DBT *, size_t *, struct mdoc *);                                  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_Cd(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_Nd(MDOC_ARGS);
 static  void              pmdoc_Nm(MDOC_ARGS);  static  void              pmdoc_Nm(MDOC_ARGS);
   static  void              pmdoc_St(MDOC_ARGS);
 static  void              pmdoc_Vt(MDOC_ARGS);  static  void              pmdoc_Vt(MDOC_ARGS);
   
 typedef void            (*pmdoc_nf)(MDOC_ARGS);  typedef void            (*pmdoc_nf)(MDOC_ARGS);
Line 104  static const pmdoc_nf   mdocs[MDOC_MAX] = {
Line 110  static const pmdoc_nf   mdocs[MDOC_MAX] = {
         NULL, /* El */          NULL, /* El */
         NULL, /* It */          NULL, /* It */
         NULL, /* Ad */          NULL, /* Ad */
         NULL, /* An */          pmdoc_An, /* An */
         NULL, /* Ar */          NULL, /* Ar */
         NULL, /* Cd */          pmdoc_Cd, /* Cd */
         NULL, /* Cm */          NULL, /* Cm */
         NULL, /* Dv */          NULL, /* Dv */
         NULL, /* Er */          NULL, /* Er */
Line 126  static const pmdoc_nf   mdocs[MDOC_MAX] = {
Line 132  static const pmdoc_nf   mdocs[MDOC_MAX] = {
         NULL, /* Ot */          NULL, /* Ot */
         NULL, /* Pa */          NULL, /* Pa */
         NULL, /* Rv */          NULL, /* Rv */
         NULL, /* St */          pmdoc_St, /* St */
         pmdoc_Vt, /* Va */          pmdoc_Vt, /* Va */
         pmdoc_Vt, /* Vt */          pmdoc_Vt, /* Vt */
         NULL, /* Xr */          NULL, /* Xr */
Line 221  main(int argc, char *argv[])
Line 227  main(int argc, char *argv[])
         struct man      *man; /* resulting man */          struct man      *man; /* resulting man */
         char            *fn; /* current file being parsed */          char            *fn; /* current file being parsed */
         const char      *msec, /* manual section */          const char      *msec, /* manual section */
                           *mtitle, /* manual title */
                           *arch, /* manual architecture */
                         *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 */
Line 354  main(int argc, char *argv[])
Line 362  main(int argc, char *argv[])
                 msec = NULL != mdoc ?                  msec = NULL != mdoc ?
                         mdoc_meta(mdoc)->msec :                          mdoc_meta(mdoc)->msec :
                         man_meta(man)->msec;                          man_meta(man)->msec;
                   mtitle = NULL != mdoc ?
                           mdoc_meta(mdoc)->title :
                           man_meta(man)->title;
                   arch = NULL != mdoc ? mdoc_meta(mdoc)->arch : NULL;
   
                 assert(msec);                  assert(msec);
                   assert(mtitle);
   
                 /*                  /*
                  * The index record value consists of a nil-terminated                   * The index record value consists of a nil-terminated
Line 368  main(int argc, char *argv[])
Line 381  main(int argc, char *argv[])
                 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);
                   dbt_appendb(&rval, &rsz, mtitle, strlen(mtitle) + 1);
                   dbt_appendb(&rval, &rsz, arch ? arch : "",
                                   arch ? strlen(arch) + 1 : 1);
   
                 sv = rval.size;                  sv = rval.size;
   
                 /* Fix the record number in the btree value. */                  /* Fix the record number in the btree value. */
Line 451  dbt_appendb(DBT *key, size_t *ksz, const void *cp, siz
Line 468  dbt_appendb(DBT *key, size_t *ksz, const void *cp, siz
                 key->data = mandoc_realloc(key->data, *ksz);                  key->data = mandoc_realloc(key->data, *ksz);
         }          }
   
   #if 0
           dstp = key->data + (int)key->size;
   
           while (NULL != (endp = memchr(cp, '\\', sz))) {
                   ssz = endp - cp;
                   memcpy(dstp, cp, ssz);
   
                   dstp += ssz;
                   key->size += ssz;
                   sz -= ssz;
   
                   cp = endp++;
                   /* FIXME: expects nil-terminated string! */
                   esc = mandoc_escape((const char **)&endp, NULL, NULL);
   
                   switch (esc) {
                   case (ESCAPE_ERROR):
                           /* Nil-terminate this point. */
                           memcpy(dstp, "", 1);
                           key->size++;
                           return;
                   case (ESCAPE_PREDEF):
                           /* FALLTHROUGH */
                   case (ESCAPE_SPECIAL):
                           break;
                   default:
                           sz -= endp - cp;
                           cp = endp;
                           continue;
                   }
   
                   ssz = endp - cp;
                   memcpy(dstp, cp, ssz);
   
                   dstp += ssz;
                   key->size += ssz;
                   sz -= ssz;
   
                   cp = endp;
           }
   #endif
   
         memcpy(key->data + (int)key->size, cp, sz);          memcpy(key->data + (int)key->size, cp, sz);
         key->size += sz;          key->size += sz;
 }  }
Line 478  dbt_append(DBT *key, size_t *ksz, const char *cp)
Line 537  dbt_append(DBT *key, size_t *ksz, const char *cp)
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
   pmdoc_An(MDOC_ARGS)
   {
           uint32_t         fl;
   
           if (SEC_AUTHORS != n->sec)
                   return;
   
           for (n = n->child; n; n = n->next)
                   if (MDOC_TEXT == n->type)
                           dbt_append(key, ksz, n->string);
   
           fl = MANDOC_AUTHOR;
           memcpy(val->data, &fl, 4);
   }
   
   /* ARGSUSED */
   static void
 pmdoc_Fd(MDOC_ARGS)  pmdoc_Fd(MDOC_ARGS)
 {  {
         uint32_t         fl;          uint32_t         fl;
         const char      *start, *end;          const char      *start, *end;
         size_t           sz;          size_t           sz;
         const char       nil = '\0';  
   
         if (SEC_SYNOPSIS != n->sec)          if (SEC_SYNOPSIS != n->sec)
                 return;                  return;
Line 517  pmdoc_Fd(MDOC_ARGS)
Line 592  pmdoc_Fd(MDOC_ARGS)
                 end--;                  end--;
   
         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, "", 1);
   
         fl = MANDOC_INCLUDES;          fl = MANDOC_INCLUDES;
         memcpy(val->data, &fl, 4);          memcpy(val->data, &fl, 4);
Line 525  pmdoc_Fd(MDOC_ARGS)
Line 600  pmdoc_Fd(MDOC_ARGS)
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
   pmdoc_Cd(MDOC_ARGS)
   {
           uint32_t         fl;
   
           if (SEC_SYNOPSIS != n->sec)
                   return;
   
           for (n = n->child; n; n = n->next)
                   if (MDOC_TEXT == n->type)
                           dbt_append(key, ksz, n->string);
   
           fl = MANDOC_CONFIG;
           memcpy(val->data, &fl, 4);
   }
   
   /* ARGSUSED */
   static void
 pmdoc_In(MDOC_ARGS)  pmdoc_In(MDOC_ARGS)
 {  {
         uint32_t         fl;          uint32_t         fl;
Line 569  pmdoc_Fn(MDOC_ARGS)
Line 661  pmdoc_Fn(MDOC_ARGS)
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
   pmdoc_St(MDOC_ARGS)
   {
           uint32_t         fl;
   
           if (SEC_STANDARDS != n->sec)
                   return;
           if (NULL == n->child || MDOC_TEXT != n->child->type)
                   return;
   
           dbt_append(key, ksz, n->child->string);
           fl = MANDOC_STANDARD;
           memcpy(val->data, &fl, 4);
   }
   
   /* ARGSUSED */
   static void
 pmdoc_Vt(MDOC_ARGS)  pmdoc_Vt(MDOC_ARGS)
 {  {
         uint32_t         fl;          uint32_t         fl;
         const char      *start, *end;          const char      *start;
         size_t           sz;          size_t           sz;
         const char       nil = '\0';  
   
         if (SEC_SYNOPSIS != n->sec)          if (SEC_SYNOPSIS != n->sec)
                 return;                  return;
Line 595  pmdoc_Vt(MDOC_ARGS)
Line 702  pmdoc_Vt(MDOC_ARGS)
         if (0 == (sz = strlen(start)))          if (0 == (sz = strlen(start)))
                 return;                  return;
   
         end = &start[sz - 1];          if (';' == start[sz - 1])
         while (end > start && ';' == *end)                  sz--;
                 end--;  
   
         if (end == start)          if (0 == sz)
                 return;                  return;
   
         dbt_appendb(key, ksz, start, end - start + 1);          dbt_appendb(key, ksz, start, sz);
         dbt_appendb(key, ksz, &nil, 1);          dbt_appendb(key, ksz, "", 1);
   
         fl = MANDOC_VARIABLE;          fl = MANDOC_VARIABLE;
         memcpy(val->data, &fl, 4);          memcpy(val->data, &fl, 4);
 }  }
Line 638  pmdoc_Nd(MDOC_ARGS)
Line 745  pmdoc_Nd(MDOC_ARGS)
                         dbt_appendb(rval, rsz, n->string, strlen(n->string) + 1);                          dbt_appendb(rval, rsz, n->string, strlen(n->string) + 1);
                 else                  else
                         dbt_append(rval, rsz, n->string);                          dbt_append(rval, rsz, n->string);
   
                 first = 0;                  first = 0;
         }          }
 }  }
Line 715  pmdoc_node(MDOC_ARGS)
Line 821  pmdoc_node(MDOC_ARGS)
                         break;                          break;
   
                 dbt_init(key, ksz);                  dbt_init(key, ksz);
                 (*mdocs[n->tok])(db, dbn, key, ksz, val, rval, rsz, 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;
         default:          default:
Line 731  static int
Line 837  static int
 pman_node(MAN_ARGS)  pman_node(MAN_ARGS)
 {  {
         const struct man_node *head, *body;          const struct man_node *head, *body;
         const char      *start;          const char      *start, *sv;
         const char       nil = '\0';  
         size_t           sz;          size_t           sz;
         uint32_t         fl;          uint32_t         fl;
   
Line 760  pman_node(MAN_ARGS)
Line 865  pman_node(MAN_ARGS)
                         fl = MANDOC_NAME;                          fl = MANDOC_NAME;
                         memcpy(val->data, &fl, 4);                          memcpy(val->data, &fl, 4);
   
                         start = body->string;                          assert(body->string);
                           start = sv = body->string;
   
                         /*                          /*
                          * Go through a special heuristic dance here.                           * Go through a special heuristic dance here.
                          * This is why -man manuals are great!                           * This is why -man manuals are great!
                            * (I'm being sarcastic: my eyes are bleeding.)
                          * Conventionally, one or more manual names are                           * Conventionally, one or more manual names are
                          * comma-specified prior to a whitespace, then a                           * comma-specified prior to a whitespace, then a
                          * dash, then a description.  Try to puzzle out                           * dash, then a description.  Try to puzzle out
                          * the name parts here.                           * the name parts here.
                          */                           */
   
                         while (start) {                          for ( ;; ) {
                                 sz = strcspn(start, " ,");                                  sz = strcspn(start, " ,");
                                 if ('\0' == start[(int)sz])                                  if ('\0' == start[(int)sz])
                                         break;                                          break;
   
                                 dbt_init(key, ksz);                                  dbt_init(key, ksz);
                                 dbt_appendb(key, ksz, start, sz);                                  dbt_appendb(key, ksz, start, sz);
                                 dbt_appendb(key, ksz, &nil, 1);                                  dbt_appendb(key, ksz, "", 1);
   
                                 dbt_put(db, dbn, key, val);                                  dbt_put(db, dbn, key, val);
   
                                 if (' ' == start[(int)sz])                                  if (' ' == start[(int)sz]) {
                                           start += (int)sz + 1;
                                         break;                                          break;
                                   }
   
                                 assert(',' == start[(int)sz]);                                  assert(',' == start[(int)sz]);
                                 start += (int)sz + 1;                                  start += (int)sz + 1;
Line 791  pman_node(MAN_ARGS)
Line 900  pman_node(MAN_ARGS)
                                         start++;                                          start++;
                         }                          }
   
                         return(1);                          if (sv == start) {
                                   dbt_init(key, ksz);
                                   dbt_append(key, ksz, start);
                                   return(1);
                           }
   
                           while (' ' == *start)
                                   start++;
   
                           if (0 == strncmp(start, "-", 1))
                                   start += 1;
                           else if (0 == strncmp(start, "\\-", 2))
                                   start += 2;
                           else if (0 == strncmp(start, "\\(en", 4))
                                   start += 4;
                           else if (0 == strncmp(start, "\\(em", 4))
                                   start += 4;
   
                           while (' ' == *start)
                                   start++;
   
                           dbt_appendb(rval, rsz, start, strlen(start) + 1);
                 }                  }
         }          }
   
Legend:
Removed from v.1.11  
changed lines
  Added in v.1.20
CVSweb