[BACK]Return to docbook2mdoc.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / docbook2mdoc

Diff for /docbook2mdoc/docbook2mdoc.c between version 1.33 and 1.37

version 1.33, 2014/04/30 09:26:10 version 1.37, 2014/04/30 12:34:44
Line 64  struct pattr {
Line 64  struct pattr {
 struct  pnode {  struct  pnode {
         enum nodeid      node; /* node type */          enum nodeid      node; /* node type */
         char            *b; /* binary data buffer */          char            *b; /* binary data buffer */
           char            *real; /* store for "b" */
         size_t           bsz; /* data buffer size */          size_t           bsz; /* data buffer size */
         struct pnode    *parent; /* parent (or NULL if top) */          struct pnode    *parent; /* parent (or NULL if top) */
         struct pnodeq    childq; /* queue of children */          struct pnodeq    childq; /* queue of children */
Line 111  static const struct node nodes[NODE__MAX] = {
Line 112  static const struct node nodes[NODE__MAX] = {
         { "group", NODE_IGNTEXT },          { "group", NODE_IGNTEXT },
         { "holder", NODE_IGNTEXT },          { "holder", NODE_IGNTEXT },
         { "info", NODE_IGNTEXT },          { "info", NODE_IGNTEXT },
           { "informaltable", NODE_IGNTEXT },
         { "itemizedlist", NODE_IGNTEXT },          { "itemizedlist", NODE_IGNTEXT },
         { "link", 0 },          { "link", 0 },
         { "listitem", NODE_IGNTEXT },          { "listitem", NODE_IGNTEXT },
Line 232  xml_char(void *arg, const XML_Char *p, int sz)
Line 234  xml_char(void *arg, const XML_Char *p, int sz)
         }          }
         memcpy(ps->cur->b + ps->cur->bsz, p, sz);          memcpy(ps->cur->b + ps->cur->bsz, p, sz);
         ps->cur->bsz += (size_t)sz;          ps->cur->bsz += (size_t)sz;
           ps->cur->real = ps->cur->b;
 }  }
   
 static void  static void
Line 269  xml_elem_start(void *arg, const XML_Char *name, const 
Line 272  xml_elem_start(void *arg, const XML_Char *name, const 
         struct pattr     *pattr;          struct pattr     *pattr;
         const XML_Char  **att;          const XML_Char  **att;
   
         if (ps->stop)          /* FIXME: find a better way to ditch other namespaces. */
           if (ps->stop || 0 == strcmp(name, "xi:include"))
                 return;                  return;
   
         /* Close out text node, if applicable... */          /* Close out text node, if applicable... */
Line 281  xml_elem_start(void *arg, const XML_Char *name, const 
Line 285  xml_elem_start(void *arg, const XML_Char *name, const 
                 ps->node = ps->cur->node;                  ps->node = ps->cur->node;
         }          }
   
   
         for (node = 0; node < NODE__MAX; node++)          for (node = 0; node < NODE__MAX; node++)
                 if (NULL == nodes[node].name)                  if (NULL == nodes[node].name)
                         continue;                          continue;
Line 389  xml_elem_end(void *arg, const XML_Char *name)
Line 394  xml_elem_end(void *arg, const XML_Char *name)
 {  {
         struct parse    *ps = arg;          struct parse    *ps = arg;
   
           /* FIXME: find a better way to ditch other namespaces. */
         if (ps->stop || NODE_ROOT == ps->node)          if (ps->stop || NODE_ROOT == ps->node)
                 return;                  return;
           else if (0 == strcmp(name, "xi:include"))
                   return;
   
         /* Close out text node, if applicable... */          /* Close out text node, if applicable... */
         if (NODE_TEXT == ps->node) {          if (NODE_TEXT == ps->node) {
Line 430  pnode_free(struct pnode *pn)
Line 438  pnode_free(struct pnode *pn)
                 free(ap);                  free(ap);
         }          }
   
         free(pn->b);          free(pn->real);
         free(pn);          free(pn);
 }  }
   
Line 614  pnode_printmclose(struct parse *p, int sv)
Line 622  pnode_printmclose(struct parse *p, int sv)
 }  }
   
 /*  /*
    * Like pnode_printmclose() except we look to the next node, and, if
    * found, see if it starts with punctuation.
    * If it does, then we print that punctuation before the newline.
    */
   static void
   pnode_printmclosepunct(struct parse *p, struct pnode *pn, int sv)
   {
           /* We wouldn't have done anything anyway. */
           if ( ! (sv && ! p->newln))
                   return;
   
           /* No next node or it's not text. */
           if (NULL == (pn = TAILQ_NEXT(pn, child))) {
                   pnode_printmclose(p, sv);
                   return;
           } else if (NODE_TEXT != pn->node) {
                   pnode_printmclose(p, sv);
                   return;
           }
   
           /* Only do this for the comma/period. */
           if (pn->bsz > 0 &&
                   (',' == pn->b[0] || '.' == pn->b[0]) &&
                   (1 == pn->bsz || isspace((int)pn->b[1]))) {
                   putchar(' ');
                   putchar(pn->b[0]);
                   pn->b++;
                   pn->bsz--;
           }
   
           putchar('\n');
           p->newln = 1;
   }
   
   /*
  * If the SYNOPSIS macro has a superfluous title, kill it.   * If the SYNOPSIS macro has a superfluous title, kill it.
  */   */
 static void  static void
Line 693  pnode_printciterefentry(struct parse *p, struct pnode 
Line 736  pnode_printciterefentry(struct parse *p, struct pnode 
         struct pnode    *pp, *title, *manvol;          struct pnode    *pp, *title, *manvol;
   
         title = manvol = NULL;          title = manvol = NULL;
         assert(p->newln);  
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_MANVOLNUM == pp->node)                  if (NODE_MANVOLNUM == pp->node)
                         manvol = pp;                          manvol = pp;
                 else if (NODE_REFENTRYTITLE == pp->node)                  else if (NODE_REFENTRYTITLE == pp->node)
                         title = pp;                          title = pp;
   
         fputs(".Xr", stdout);  
         p->newln = 0;  
   
         if (NULL != title) {          if (NULL != title) {
                 pnode_printmacrolinepart(p, title);                  pnode_printmacrolinepart(p, title);
         } else          } else
Line 712  pnode_printciterefentry(struct parse *p, struct pnode 
Line 751  pnode_printciterefentry(struct parse *p, struct pnode 
                 puts(" 1");                  puts(" 1");
                 p->newln = 1;                  p->newln = 1;
         } else          } else
                 pnode_printmacroline(p, manvol);                  pnode_printmacrolinepart(p, manvol);
 }  }
   
 static void  static void
Line 1087  pnode_print(struct parse *p, struct pnode *pn)
Line 1126  pnode_print(struct parse *p, struct pnode *pn)
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_CITEREFENTRY):          case (NODE_CITEREFENTRY):
                 assert(p->newln);                  pnode_printmopen(p);
                   fputs("Xr", stdout);
                 pnode_printciterefentry(p, pn);                  pnode_printciterefentry(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
Line 1239  pnode_print(struct parse *p, struct pnode *pn)
Line 1279  pnode_print(struct parse *p, struct pnode *pn)
                 fputs("Vt", stdout);                  fputs("Vt", stdout);
                 break;                  break;
         case (NODE_TABLE):          case (NODE_TABLE):
                   /* FALLTHROUGH */
           case (NODE_INFORMALTABLE):
                 assert(p->newln);                  assert(p->newln);
                 pnode_printtable(p, pn);                  pnode_printtable(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
Line 1246  pnode_print(struct parse *p, struct pnode *pn)
Line 1288  pnode_print(struct parse *p, struct pnode *pn)
         case (NODE_TEXT):          case (NODE_TEXT):
                 if (0 == p->newln)                  if (0 == p->newln)
                         putchar(' ');                          putchar(' ');
   
                 bufclear(p);                  bufclear(p);
                 bufappend(p, pn);                  bufappend(p, pn);
   
                   if (0 == p->bsz) {
                           assert(pn->real != pn->b);
                           break;
                   }
   
                 /*                  /*
                  * Output all characters, squeezing out whitespace                   * Output all characters, squeezing out whitespace
                  * between newlines.                   * between newlines.
Line 1256  pnode_print(struct parse *p, struct pnode *pn)
Line 1305  pnode_print(struct parse *p, struct pnode *pn)
                  */                   */
                 assert(p->bsz);                  assert(p->bsz);
                 cp = p->b;                  cp = p->b;
   
                 /*                  /*
                  * There's often a superfluous "-" in its <option> tags                   * There's often a superfluous "-" in its <option> tags
                  * before the actual flags themselves.                   * before the actual flags themselves.
Line 1309  pnode_print(struct parse *p, struct pnode *pn)
Line 1359  pnode_print(struct parse *p, struct pnode *pn)
         switch (pn->node) {          switch (pn->node) {
         case (NODE_APPLICATION):          case (NODE_APPLICATION):
         case (NODE_ARG):          case (NODE_ARG):
           case (NODE_CITEREFENTRY):
         case (NODE_CODE):          case (NODE_CODE):
         case (NODE_COMMAND):          case (NODE_COMMAND):
         case (NODE_CONSTANT):          case (NODE_CONSTANT):
Line 1327  pnode_print(struct parse *p, struct pnode *pn)
Line 1378  pnode_print(struct parse *p, struct pnode *pn)
         case (NODE_TEXT):          case (NODE_TEXT):
         case (NODE_USERINPUT):          case (NODE_USERINPUT):
         case (NODE_VARNAME):          case (NODE_VARNAME):
                 pnode_printmclose(p, sv);                  pnode_printmclosepunct(p, pn, sv);
                 break;                  break;
         case (NODE_QUOTE):          case (NODE_QUOTE):
                 pnode_printmclose(p, sv);                  pnode_printmclose(p, sv);
Legend:
Removed from v.1.33  
changed lines
  Added in v.1.37
CVSweb