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

Diff for /docbook2mdoc/docbook2mdoc.c between version 1.9 and 1.10

version 1.9, 2014/03/28 13:16:40 version 1.10, 2014/03/29 10:56:21
Line 78  struct parse {
Line 78  struct parse {
         char            *b; /* nil-terminated buffer for pre-print */          char            *b; /* nil-terminated buffer for pre-print */
         size_t           bsz; /* current length of b */          size_t           bsz; /* current length of b */
         size_t           mbsz; /* max bsz allocation */          size_t           mbsz; /* max bsz allocation */
           int              newln; /* output: are we on a fresh line */
 };  };
   
 struct  node {  struct  node {
Line 132  static const struct node nodes[NODE__MAX] = {
Line 133  static const struct node nodes[NODE__MAX] = {
         { "title", 0 },          { "title", 0 },
 };  };
   
   static void
   pnode_print(struct parse *p, struct pnode *pn);
   
 /*  /*
  * Look up whether "parent" is a valid parent for "node".   * Look up whether "parent" is a valid parent for "node".
  * This is sucked directly from the DocBook specification: look at the   * This is sucked directly from the DocBook specification: look at the
Line 414  xml_char(void *arg, const XML_Char *p, int sz)
Line 418  xml_char(void *arg, const XML_Char *p, int sz)
          * If we're not processing text right now, then create a text           * If we're not processing text right now, then create a text
          * node for doing so.           * node for doing so.
          * However, don't do so unless we have some non-whitespace to           * However, don't do so unless we have some non-whitespace to
          * process!           * process: strip out all leading whitespace to be sure.
          */           */
         if (NODE_TEXT != ps->node) {          if (NODE_TEXT != ps->node) {
                 for (i = 0; i < sz; i++)                  for (i = 0; i < sz; i++)
Line 422  xml_char(void *arg, const XML_Char *p, int sz)
Line 426  xml_char(void *arg, const XML_Char *p, int sz)
                                 break;                                  break;
                 if (i == sz)                  if (i == sz)
                         return;                          return;
                   p += i;
                   sz -= i;
                 dat = calloc(1, sizeof(struct pnode));                  dat = calloc(1, sizeof(struct pnode));
                 if (NULL == dat) {                  if (NULL == dat) {
                         perror(NULL);                          perror(NULL);
Line 434  xml_char(void *arg, const XML_Char *p, int sz)
Line 440  xml_char(void *arg, const XML_Char *p, int sz)
                 TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child);                  TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child);
                 ps->cur = dat;                  ps->cur = dat;
                 assert(NULL != ps->root);                  assert(NULL != ps->root);
   
         }          }
   
         /* Append to current buffer. */          /* Append to current buffer. */
Line 449  xml_char(void *arg, const XML_Char *p, int sz)
Line 454  xml_char(void *arg, const XML_Char *p, int sz)
         ps->cur->bsz += (size_t)sz;          ps->cur->bsz += (size_t)sz;
 }  }
   
   static void
   pnode_trim(struct pnode *pn)
   {
   
           assert(NODE_TEXT == pn->node);
           for ( ; pn->bsz > 0; pn->bsz--)
                   if ( ! isspace((int)pn->b[pn->bsz - 1]))
                           break;
   }
   
 /*  /*
  * Begin an element.   * Begin an element.
  * First, look for the element.   * First, look for the element.
Line 476  xml_elem_start(void *arg, const XML_Char *name, const 
Line 491  xml_elem_start(void *arg, const XML_Char *name, const 
         /* Close out text node, if applicable... */          /* Close out text node, if applicable... */
         if (NODE_TEXT == ps->node) {          if (NODE_TEXT == ps->node) {
                 assert(NULL != ps->cur);                  assert(NULL != ps->cur);
                   pnode_trim(ps->cur);
                 ps->cur = ps->cur->parent;                  ps->cur = ps->cur->parent;
                 assert(NULL != ps->cur);                  assert(NULL != ps->cur);
                 ps->node = ps->cur->node;                  ps->node = ps->cur->node;
Line 541  xml_elem_end(void *arg, const XML_Char *name)
Line 557  xml_elem_end(void *arg, const XML_Char *name)
         /* Close out text node, if applicable... */          /* Close out text node, if applicable... */
         if (NODE_TEXT == ps->node) {          if (NODE_TEXT == ps->node) {
                 assert(NULL != ps->cur);                  assert(NULL != ps->cur);
                   pnode_trim(ps->cur);
                 ps->cur = ps->cur->parent;                  ps->cur = ps->cur->parent;
                 assert(NULL != ps->cur);                  assert(NULL != ps->cur);
                 ps->node = ps->cur->node;                  ps->node = ps->cur->node;
Line 694  pnode_printmacroline(struct parse *p, struct pnode *pn
Line 711  pnode_printmacroline(struct parse *p, struct pnode *pn
         putchar('\n');          putchar('\n');
 }  }
   
   static void
   pnode_printmopen(struct parse *p)
   {
           if (p->newln) {
                   putchar('.');
                   p->newln = 0;
           } else
                   putchar(' ');
   }
   
   static void
   pnode_printmclose(struct parse *p, int sv)
   {
   
           if (sv && ! p->newln) {
                   putchar('\n');
                   p->newln = 1;
           }
   }
   
 /*  /*
  * Start the SYNOPSIS macro, unlinking its [superfluous] title.   * If the SYNOPSIS macro has a superfluous title, kill it.
  */   */
 static void  static void
 pnode_printrefsynopsisdiv(struct parse *p, struct pnode *pn)  pnode_printrefsynopsisdiv(struct parse *p, struct pnode *pn)
 {  {
         struct pnode    *pp;          struct pnode    *pp;
   
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_TITLE == pp->node) {                  if (NODE_TITLE == pp->node) {
                         pnode_unlink(pp);                          pnode_unlink(pp);
                         break;                          return;
                 }                  }
   
         puts(".Sh SYNOPSIS");  
 }  }
   
 /*  /*
Line 862  pnode_printfuncprototype(struct parse *p, struct pnode
Line 897  pnode_printfuncprototype(struct parse *p, struct pnode
         puts(".Fc");          puts(".Fc");
 }  }
   
 /* TODO: handle "optional" values. */  /*
    * The <arg> element is more complicated than it should be because text
    * nodes are treated like ".Ar foo", but non-text nodes need to be
    * re-sent into the printer (i.e., without the preceding ".Ar").
    * TODO: handle "optional" attribute.
    */
 static void  static void
 pnode_printarg(struct parse *p, struct pnode *pn, int nested)  pnode_printarg(struct parse *p, struct pnode *pn)
 {  {
         struct pnode    *pp;          struct pnode    *pp;
         int              sv = nested;  
   
         if ( ! nested)          TAILQ_FOREACH(pp, &pn->childq, child) {
                 fputs(".", stdout);                  if (NODE_TEXT == pp->node) {
         nested = 1;                          pnode_printmopen(p);
         TAILQ_FOREACH(pp, &pn->childq, child)  
                 if (NODE_OPTION == pp->node) {  
                         fputs("Fl ", stdout);  
                         pnode_printmacrolinepart(p, pp);  
                 } else if (NODE_TEXT == pp->node) {  
                         fputs("Ar ", stdout);                          fputs("Ar ", stdout);
                         pnode_printmacrolinepart(p, pp);                  }
                 } else if (NODE_ARG == pp->node)                  pnode_print(p, pp);
                         pnode_printarg(p, pp, nested);          }
   
         if ( ! sv)  
                 puts("");  
 }  }
   
 /*  /*
Line 934  pnode_print(struct parse *p, struct pnode *pn)
Line 965  pnode_print(struct parse *p, struct pnode *pn)
 {  {
         struct pnode    *pp;          struct pnode    *pp;
         char            *cp;          char            *cp;
         int              last;          int              last, sv;
   
         if (NULL == pn)          if (NULL == pn)
                 return;                  return;
   
         if (NODE_TEXT != pn->node && NODE_ROOT != pn->node)          sv = p->newln;
                 printf(".\\\" %s\n", nodes[pn->node].name);  
   
         switch (pn->node) {          switch (pn->node) {
         case (NODE_ARG):          case (NODE_ARG):
                 pnode_printarg(p, pn, 0);                  pnode_printarg(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_CITEREFENTRY):          case (NODE_CITEREFENTRY):
                   assert(p->newln);
                 pnode_printciterefentry(p, pn);                  pnode_printciterefentry(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_CODE):          case (NODE_CODE):
                 fputs(".Li ", stdout);                  pnode_printmopen(p);
                 pnode_printmacroline(p, pn);                  fputs("Li ", stdout);
                 pnode_unlinksub(pn);  
                 break;                  break;
         case (NODE_COMMAND):          case (NODE_COMMAND):
                 fputs(".Nm ", stdout);                  pnode_printmopen(p);
                 pnode_printmacroline(p, pn);                  fputs("Nm ", stdout);
                 pnode_unlinksub(pn);  
                 break;                  break;
         case (NODE_FUNCTION):          case (NODE_FUNCTION):
                 fputs(".Fn ", stdout);                  pnode_printmopen(p);
                 pnode_printmacroline(p, pn);                  fputs("Fn ", stdout);
                 pnode_unlinksub(pn);  
                 break;                  break;
         case (NODE_FUNCPROTOTYPE):          case (NODE_FUNCPROTOTYPE):
                   assert(p->newln);
                 pnode_printfuncprototype(p, pn);                  pnode_printfuncprototype(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_FUNCSYNOPSISINFO):          case (NODE_FUNCSYNOPSISINFO):
                 fputs(".Fd ", stdout);                  pnode_printmopen(p);
                 pnode_printmacroline(p, pn);                  fputs("Fd ", stdout);
                 pnode_unlinksub(pn);  
                 break;                  break;
           case (NODE_OPTION):
                   pnode_printmopen(p);
                   fputs("Fl ", stdout);
                   break;
         case (NODE_PARA):          case (NODE_PARA):
                 /* FIXME: not always. */                  assert(p->newln);
                 puts(".Pp");                  puts(".Pp");
                 break;                  break;
         case (NODE_PARAMETER):          case (NODE_PARAMETER):
                 fputs(".Fa \"", stdout);                  /* Suppress non-text children... */
                   pnode_printmopen(p);
                   fputs("Fa \"", stdout);
                 pnode_printmacrolinepart(p, pn);                  pnode_printmacrolinepart(p, pn);
                 puts("\"");                  puts("\"");
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_PROGRAMLISTING):          case (NODE_PROGRAMLISTING):
                   assert(p->newln);
                 puts(".Bd -literal");                  puts(".Bd -literal");
                 break;                  break;
         case (NODE_REFMETA):          case (NODE_REFMETA):
                 abort();                  abort();
                 break;                  break;
         case (NODE_REFNAME):          case (NODE_REFNAME):
                 fputs(".Nm ", stdout);                  /* Suppress non-text children... */
                 pnode_printmacroline(p, pn);                  pnode_printmopen(p);
                   fputs("Nm ", stdout);
                   pnode_printmacrolinepart(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 return;                  break;
         case (NODE_REFNAMEDIV):          case (NODE_REFNAMEDIV):
                   assert(p->newln);
                 puts(".Sh NAME");                  puts(".Sh NAME");
                 break;                  break;
         case (NODE_REFPURPOSE):          case (NODE_REFPURPOSE):
                   assert(p->newln);
                 fputs(".Nd ", stdout);                  fputs(".Nd ", stdout);
                 pnode_printmacroline(p, pn);                  break;
                 pnode_unlinksub(pn);  
                 return;  
         case (NODE_REFSYNOPSISDIV):          case (NODE_REFSYNOPSISDIV):
                   assert(p->newln);
                 pnode_printrefsynopsisdiv(p, pn);                  pnode_printrefsynopsisdiv(p, pn);
                   puts(".Sh SYNOPSIS");
                 break;                  break;
         case (NODE_REFSECT1):          case (NODE_REFSECT1):
                   assert(p->newln);
                 pnode_printrefsect(p, pn);                  pnode_printrefsect(p, pn);
                 break;                  break;
         case (NODE_STRUCTNAME):          case (NODE_STRUCTNAME):
                 fputs(".Vt ", stdout);                  pnode_printmopen(p);
                 pnode_printmacroline(p, pn);                  fputs("Vt ", stdout);
                 pnode_unlinksub(pn);                  break;
                 return;  
         case (NODE_TEXT):          case (NODE_TEXT):
                 bufclear(p);                  bufclear(p);
                 bufappend(p, pn);                  bufappend(p, pn);
Line 1024  pnode_print(struct parse *p, struct pnode *pn)
Line 1063  pnode_print(struct parse *p, struct pnode *pn)
                  * XXX: all whitespace, including tabs (?).                   * XXX: all whitespace, including tabs (?).
                  * Remember to escape control characters and escapes.                   * Remember to escape control characters and escapes.
                  */                   */
                   assert(p->bsz);
                 for (last = '\n', cp = p->b; '\0' != *cp; ) {                  for (last = '\n', cp = p->b; '\0' != *cp; ) {
                         if ('\n' == last) {                          if ('\n' == last) {
                                 /* Consume all whitespace. */                                  /* Consume all whitespace. */
Line 1039  pnode_print(struct parse *p, struct pnode *pn)
Line 1079  pnode_print(struct parse *p, struct pnode *pn)
                         if ('\\' == last)                          if ('\\' == last)
                                 putchar('e');                                  putchar('e');
                 }                  }
                 if ('\n' != last)                  p->newln = 0;
                         putchar('\n');  
                 break;                  break;
         default:          default:
                 break;                  break;
Line 1050  pnode_print(struct parse *p, struct pnode *pn)
Line 1089  pnode_print(struct parse *p, struct pnode *pn)
                 pnode_print(p, pp);                  pnode_print(p, pp);
   
         switch (pn->node) {          switch (pn->node) {
           case (NODE_ARG):
           case (NODE_CODE):
           case (NODE_COMMAND):
           case (NODE_FUNCTION):
           case (NODE_FUNCSYNOPSISINFO):
           case (NODE_OPTION):
           case (NODE_PARAMETER):
           case (NODE_REFNAME):
           case (NODE_STRUCTNAME):
           case (NODE_TEXT):
                   pnode_printmclose(p, sv);
                   break;
         case (NODE_PROGRAMLISTING):          case (NODE_PROGRAMLISTING):
                   assert(p->newln);
                 puts(".Ed");                  puts(".Ed");
                   p->newln = 1;
                 break;                  break;
         default:          default:
                 break;                  break;
Line 1089  readfile(XML_Parser xp, int fd, 
Line 1142  readfile(XML_Parser xp, int fd, 
                  * Exit when we've read all or errors have occured                   * Exit when we've read all or errors have occured
                  * during the parse sequence.                   * during the parse sequence.
                  */                   */
                   p.newln = 1;
                 pnode_printprologue(&p, p.root);                  pnode_printprologue(&p, p.root);
                 pnode_print(&p, p.root);                  pnode_print(&p, p.root);
                 pnode_free(p.root);                  pnode_free(p.root);

Legend:
Removed from v.1.9  
changed lines
  Added in v.1.10

CVSweb