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

Diff for /docbook2mdoc/docbook2mdoc.c between version 1.12 and 1.13

version 1.12, 2014/03/29 22:44:06 version 1.13, 2014/03/30 11:48:10
Line 26 
Line 26 
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
   
 /*  #include "extern.h"
  * All recognised node types.  
  */  
 enum    nodeid {  
         NODE_ROOT = 0, /* Must comes first. */  
         /* Alpha-ordered hereafter. */  
         NODE_ARG,  
         NODE_CITEREFENTRY,  
         NODE_CMDSYNOPSIS,  
         NODE_CODE,  
         NODE_COMMAND,  
         NODE_FUNCDEF,  
         NODE_FUNCPROTOTYPE,  
         NODE_FUNCSYNOPSIS,  
         NODE_FUNCSYNOPSISINFO,  
         NODE_FUNCTION,  
         NODE_MANVOLNUM,  
         NODE_OPTION,  
         NODE_PARA,  
         NODE_PARAMDEF,  
         NODE_PARAMETER,  
         NODE_PROGRAMLISTING,  
         NODE_REFCLASS,  
         NODE_REFDESCRIPTOR,  
         NODE_REFENTRY,  
         NODE_REFENTRYTITLE,  
         NODE_REFMETA,  
         NODE_REFMISCINFO,  
         NODE_REFNAME,  
         NODE_REFNAMEDIV,  
         NODE_REFPURPOSE,  
         NODE_REFSECT1,  
         NODE_REFSYNOPSISDIV,  
         NODE_STRUCTNAME,  
         NODE_SYNOPSIS,  
         NODE_TEXT,  
         NODE_TITLE,  
         NODE__MAX  
 };  
   
 /*  /*
  * All recognised attribute keys.  
  */  
 enum    attrkey {  
         /* Alpha-order... */  
         ATTRKEY_CHOICE = 0,  
         ATTRKEY_ID,  
         ATTRKEY_REP,  
         ATTRKEY__MAX  
 };  
   
 /*  
  * All [explicitly] recognised attribute values.  
  * If an attribute has ATTRVAL__MAX, it could be a free-form.  
  */  
 enum    attrval {  
         /* Alpha-order... */  
         ATTRVAL_NOREPEAT,  
         ATTRVAL_OPT,  
         ATTRVAL_PLAIN,  
         ATTRVAL_REPEAT,  
         ATTRVAL_REQ,  
         ATTRVAL__MAX  
 };  
   
 /*  
  * Global parse state.   * Global parse state.
  * Keep this as simple and small as possible.   * Keep this as simple and small as possible.
  */   */
Line 155  static const struct node nodes[NODE__MAX] = {
Line 92  static const struct node nodes[NODE__MAX] = {
         { "cmdsynopsis", NODE_IGNTEXT },          { "cmdsynopsis", NODE_IGNTEXT },
         { "code", 0 },          { "code", 0 },
         { "command", 0 },          { "command", 0 },
           { "emphasis", 0 },
         { "funcdef", 0 },          { "funcdef", 0 },
         { "funcprototype", NODE_IGNTEXT },          { "funcprototype", NODE_IGNTEXT },
         { "funcsynopsis", NODE_IGNTEXT },          { "funcsynopsis", NODE_IGNTEXT },
         { "funcsynopsisinfo", 0 },          { "funcsynopsisinfo", 0 },
         { "function", 0 },          { "function", 0 },
           { "listitem", NODE_IGNTEXT },
         { "manvolnum", 0 },          { "manvolnum", 0 },
         { "option", 0 },          { "option", 0 },
         { "para", 0 },          { "para", 0 },
Line 177  static const struct node nodes[NODE__MAX] = {
Line 116  static const struct node nodes[NODE__MAX] = {
         { "refpurpose", 0 },          { "refpurpose", 0 },
         { "refsect1", 0 },          { "refsect1", 0 },
         { "refsynopsisdiv", NODE_IGNTEXT },          { "refsynopsisdiv", NODE_IGNTEXT },
           { "replaceable", 0 },
         { "structname", 0 },          { "structname", 0 },
         { "synopsis", 0 },          { "synopsis", 0 },
           { "term", 0 },
         { NULL, 0 },          { NULL, 0 },
         { "title", 0 },          { "title", 0 },
           { "variablelist", NODE_IGNTEXT },
           { "varlistentry", NODE_IGNTEXT },
 };  };
   
 static void  static void
 pnode_print(struct parse *p, struct pnode *pn);  pnode_print(struct parse *p, struct pnode *pn);
   
 static int  
 isattrkey(enum nodeid node, enum attrkey key)  
 {  
   
         switch (key) {  
         case (ATTRKEY_CHOICE):  
                 return(node == NODE_ARG);  
         case (ATTRKEY_ID):  
                 /* Common to all. */  
                 return(1);  
         case (ATTRKEY_REP):  
                 return(node == NODE_ARG);  
         default:  
                 break;  
         }  
         abort();  
         return(0);  
 }  
   
 static int  
 isattrval(enum attrkey key, enum attrval val)  
 {  
   
         switch (val) {  
         case (ATTRVAL_OPT):  
         case (ATTRVAL_PLAIN):  
         case (ATTRVAL_REQ):  
                 return(key == ATTRKEY_CHOICE);  
         case (ATTRVAL_REPEAT):  
         case (ATTRVAL_NOREPEAT):  
                 return(key == ATTRKEY_REP);  
         default:  
                 break;  
         }  
         abort();  
         return(0);  
 }  
   
 /*  /*
  * Look up whether "parent" is a valid parent for "node".  
  * This is sucked directly from the DocBook specification: look at the  
  * "children" and "parent" sections of each node.  
  */  
 static int  
 isparent(enum nodeid node, enum nodeid parent)  
 {  
   
         switch (node) {  
         case (NODE_ROOT):  
                 return(0);  
         case (NODE_ARG):  
                 switch (parent) {  
                 case (NODE_ARG):  
                 case (NODE_CMDSYNOPSIS):  
                         return(1);  
                 default:  
                         break;  
                 }  
                 return(0);  
         case (NODE_CITEREFENTRY):  
                 switch (parent) {  
                 case (NODE_FUNCSYNOPSISINFO):  
                 case (NODE_PARA):  
                 case (NODE_PROGRAMLISTING):  
                 case (NODE_REFDESCRIPTOR):  
                 case (NODE_REFENTRYTITLE):  
                 case (NODE_REFNAME):  
                 case (NODE_REFPURPOSE):  
                 case (NODE_SYNOPSIS):  
                 case (NODE_TITLE):  
                         return(1);  
                 default:  
                         break;  
                 }  
                 return(0);  
         case (NODE_CMDSYNOPSIS):  
                 switch (parent) {  
                 case (NODE_PARA):  
                 case (NODE_REFSECT1):  
                 case (NODE_REFSYNOPSISDIV):  
                         return(1);  
                 default:  
                         break;  
                 }  
                 return(0);  
         case (NODE_CODE):  
                 switch (parent) {  
                 case (NODE_FUNCSYNOPSISINFO):  
                 case (NODE_PARA):  
                 case (NODE_PROGRAMLISTING):  
                 case (NODE_REFDESCRIPTOR):  
                 case (NODE_REFENTRYTITLE):  
                 case (NODE_REFNAME):  
                 case (NODE_REFPURPOSE):  
                 case (NODE_SYNOPSIS):  
                 case (NODE_TITLE):  
                         return(1);  
                 default:  
                         break;  
                 }  
                 return(0);  
         case (NODE_COMMAND):  
                 switch (parent) {  
                 case (NODE_CMDSYNOPSIS):  
                 case (NODE_FUNCSYNOPSISINFO):  
                 case (NODE_PARA):  
                 case (NODE_PROGRAMLISTING):  
                 case (NODE_REFDESCRIPTOR):  
                 case (NODE_REFENTRYTITLE):  
                 case (NODE_REFNAME):  
                 case (NODE_REFPURPOSE):  
                 case (NODE_SYNOPSIS):  
                 case (NODE_TITLE):  
                         return(1);  
                 default:  
                         break;  
                 }  
                 return(0);  
         case (NODE_FUNCDEF):  
                 return(NODE_FUNCPROTOTYPE == parent);  
         case (NODE_FUNCPROTOTYPE):  
                 return(NODE_FUNCSYNOPSIS == parent);  
         case (NODE_FUNCSYNOPSIS):  
                 switch (parent) {  
                 case (NODE_PARA):  
                 case (NODE_REFSECT1):  
                 case (NODE_REFSYNOPSISDIV):  
                         return(1);  
                 default:  
                         break;  
                 }  
                 return(0);  
         case (NODE_FUNCSYNOPSISINFO):  
                 return(NODE_FUNCSYNOPSIS == parent);  
         case (NODE_FUNCTION):  
                 switch (parent) {  
                 case (NODE_CODE):  
                 case (NODE_FUNCDEF):  
                 case (NODE_FUNCSYNOPSISINFO):  
                 case (NODE_PARA):  
                 case (NODE_PROGRAMLISTING):  
                 case (NODE_REFDESCRIPTOR):  
                 case (NODE_REFENTRYTITLE):  
                 case (NODE_REFNAME):  
                 case (NODE_REFPURPOSE):  
                 case (NODE_SYNOPSIS):  
                 case (NODE_TITLE):  
                         return(1);  
                 default:  
                         break;  
                 }  
                 return(0);  
         case (NODE_MANVOLNUM):  
                 switch (parent) {  
                 case (NODE_CITEREFENTRY):  
                 case (NODE_REFMETA):  
                         return(1);  
                 default:  
                         break;  
                 }  
                 return(0);  
         case (NODE_OPTION):  
                 switch (parent) {  
                 case (NODE_ARG):  
                 case (NODE_FUNCSYNOPSISINFO):  
                 case (NODE_PARA):  
                 case (NODE_PROGRAMLISTING):  
                 case (NODE_REFDESCRIPTOR):  
                 case (NODE_REFENTRYTITLE):  
                 case (NODE_REFNAME):  
                 case (NODE_REFPURPOSE):  
                 case (NODE_SYNOPSIS):  
                 case (NODE_TITLE):  
                         return(1);  
                 default:  
                         break;  
                 }  
                 return(0);  
         case (NODE_PARA):  
                 switch (parent) {  
                 case (NODE_REFSECT1):  
                 case (NODE_REFSYNOPSISDIV):  
                         return(1);  
                 default:  
                         break;  
                 }  
                 return(0);  
         case (NODE_PARAMDEF):  
                 return(NODE_FUNCPROTOTYPE == parent);  
         case (NODE_PARAMETER):  
                 switch (parent) {  
                 case (NODE_CODE):  
                 case (NODE_FUNCSYNOPSISINFO):  
                 case (NODE_PARA):  
                 case (NODE_PARAMDEF):  
                 case (NODE_PROGRAMLISTING):  
                 case (NODE_REFDESCRIPTOR):  
                 case (NODE_REFENTRYTITLE):  
                 case (NODE_REFNAME):  
                 case (NODE_REFPURPOSE):  
                 case (NODE_SYNOPSIS):  
                 case (NODE_TITLE):  
                         return(1);  
                 default:  
                         break;  
                 }  
                 return(0);  
         case (NODE_PROGRAMLISTING):  
                 switch (parent) {  
                 case (NODE_PARA):  
                 case (NODE_REFSECT1):  
                 case (NODE_REFSYNOPSISDIV):  
                         return(1);  
                 default:  
                         break;  
                 }  
                 return(0);  
         case (NODE_REFCLASS):  
                 return(parent == NODE_REFNAMEDIV);  
         case (NODE_REFDESCRIPTOR):  
                 return(parent == NODE_REFNAMEDIV);  
         case (NODE_REFENTRY):  
                 return(parent == NODE_ROOT);  
         case (NODE_REFENTRYTITLE):  
                 switch (parent) {  
                 case (NODE_CITEREFENTRY):  
                 case (NODE_REFMETA):  
                         return(1);  
                 default:  
                         break;  
                 }  
         case (NODE_REFMETA):  
                 return(parent == NODE_REFENTRY);  
         case (NODE_REFMISCINFO):  
                 return(parent == NODE_REFMETA);  
         case (NODE_REFNAME):  
                 return(parent == NODE_REFNAMEDIV);  
         case (NODE_REFNAMEDIV):  
                 return(parent == NODE_REFENTRY);  
         case (NODE_REFPURPOSE):  
                 return(parent == NODE_REFNAMEDIV);  
         case (NODE_REFSECT1):  
                 return(parent == NODE_REFENTRY);  
         case (NODE_REFSYNOPSISDIV):  
                 return(parent == NODE_REFENTRY);  
         case (NODE_STRUCTNAME):  
                 switch (parent) {  
                 case (NODE_CODE):  
                 case (NODE_FUNCSYNOPSISINFO):  
                 case (NODE_FUNCTION):  
                 case (NODE_OPTION):  
                 case (NODE_PARA):  
                 case (NODE_PARAMETER):  
                 case (NODE_PROGRAMLISTING):  
                 case (NODE_REFDESCRIPTOR):  
                 case (NODE_REFENTRYTITLE):  
                 case (NODE_REFNAME):  
                 case (NODE_REFPURPOSE):  
                 case (NODE_SYNOPSIS):  
                 case (NODE_TITLE):  
                         return(1);  
                 default:  
                         break;  
                 }  
                 return(0);  
         case (NODE_SYNOPSIS):  
                 switch (parent) {  
                 case (NODE_REFSYNOPSISDIV):  
                 case (NODE_REFSECT1):  
                         return(1);  
                 default:  
                         break;  
                 }  
                 return(0);  
         case (NODE_TITLE):  
                 switch (parent) {  
                 case (NODE_REFSECT1):  
                 case (NODE_REFSYNOPSISDIV):  
                         return(1);  
                 default:  
                         break;  
                 }  
                 return(0);  
         case (NODE_TEXT):  
                 return(1);  
         case (NODE__MAX):  
                 break;  
         }  
   
         abort();  
         return(0);  
 }  
   
 /*  
  * Process a stream of characters.   * Process a stream of characters.
  * We store text as nodes in and of themselves.   * We store text as nodes in and of themselves.
  * If a text node is already open, append to it.   * If a text node is already open, append to it.
Line 613  xml_elem_start(void *arg, const XML_Char *name, const 
Line 263  xml_elem_start(void *arg, const XML_Char *name, const 
         } else if (NODE_ROOT == ps->node && NODE_REFENTRY != node) {          } else if (NODE_ROOT == ps->node && NODE_REFENTRY != node) {
                 return;                  return;
         } else if ( ! isparent(node, ps->node)) {          } else if ( ! isparent(node, ps->node)) {
                 fprintf(stderr, "%s:%zu:%zu: bad parent \"%s\"\n",                  fprintf(stderr, "%s:%zu:%zu: bad parent \"%s\" "
                           "of node \"%s\"\n",
                         ps->fname, XML_GetCurrentLineNumber(ps->xml),                          ps->fname, XML_GetCurrentLineNumber(ps->xml),
                         XML_GetCurrentColumnNumber(ps->xml),                          XML_GetCurrentColumnNumber(ps->xml),
                         NULL == nodes[ps->node].name ?                          NULL == nodes[ps->node].name ?
                         "(none)" : nodes[ps->node].name);                          "(none)" : nodes[ps->node].name,
                           NULL == nodes[node].name ?
                           "(none)" : nodes[node].name);
                 ps->stop = 1;                  ps->stop = 1;
                 return;                  return;
         }          }
Line 820  pnode_printmacrolinetext(struct parse *p, struct pnode
Line 473  pnode_printmacrolinetext(struct parse *p, struct pnode
 {  {
         char            *cp;          char            *cp;
   
           if (0 == p->newln)
                   putchar(' ');
   
         bufclear(p);          bufclear(p);
         bufappend_r(p, pn);          bufappend_r(p, pn);
   
Line 867  static void
Line 523  static void
 pnode_printmacroline(struct parse *p, struct pnode *pn)  pnode_printmacroline(struct parse *p, struct pnode *pn)
 {  {
   
           assert(0 == p->newln);
         pnode_printmacrolinetext(p, pn, 0);          pnode_printmacrolinetext(p, pn, 0);
         putchar('\n');          putchar('\n');
           p->newln = 1;
 }  }
   
 static void  static void
Line 918  pnode_printrefsect(struct parse *p, struct pnode *pn)
Line 576  pnode_printrefsect(struct parse *p, struct pnode *pn)
                 if (NODE_TITLE == pp->node)                  if (NODE_TITLE == pp->node)
                         break;                          break;
   
         fputs(".Sh ", stdout);          fputs(".Sh", stdout);
           p->newln = 0;
   
         if (NULL != pp) {          if (NULL != pp) {
                 pnode_printmacroline(p, pp);                  pnode_printmacroline(p, pp);
                 pnode_unlink(pp);                  pnode_unlink(pp);
         } else          } else {
                 puts("UNKNOWN");                  puts("UNKNOWN");
                   p->newln = 1;
           }
 }  }
   
 /*  /*
Line 936  pnode_printciterefentry(struct parse *p, struct pnode 
Line 597  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);          fputs(".Xr", stdout);
           p->newln = 0;
   
         if (NULL != title) {          if (NULL != title) {
                 pnode_printmacrolinepart(p, title);                  pnode_printmacrolinepart(p, title);
                 putchar(' ');  
         } else          } else
                 fputs("unknown ", stdout);                  fputs(" unknown ", stdout);
   
         if (NULL != manvol)          if (NULL == manvol) {
                   puts(" 1");
                   p->newln = 1;
           } else
                 pnode_printmacroline(p, manvol);                  pnode_printmacroline(p, manvol);
         else  
                 puts("1");  
 }  }
   
 static void  static void
Line 962  pnode_printrefmeta(struct parse *p, struct pnode *pn)
Line 625  pnode_printrefmeta(struct parse *p, struct pnode *pn)
         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;
Line 969  pnode_printrefmeta(struct parse *p, struct pnode *pn)
Line 633  pnode_printrefmeta(struct parse *p, struct pnode *pn)
                         title = pp;                          title = pp;
   
         puts(".Dd $Mdocdate" "$");          puts(".Dd $Mdocdate" "$");
         fputs(".Dt ", stdout);          fputs(".Dt", stdout);
           p->newln = 0;
   
         if (NULL != title) {          if (NULL != title)
                 /* FIXME: uppercase. */  
                 pnode_printmacrolinetext(p, title, MACROLINE_UPPER);                  pnode_printmacrolinetext(p, title, MACROLINE_UPPER);
                 putchar(' ');          else
         } else                  fputs(" UNKNOWN ", stdout);
                 fputs("UNKNOWN ", stdout);  
   
         if (NULL != manvol)          if (NULL == manvol) {
                   puts(" 1");
                   p->newln = 1;
           } else
                 pnode_printmacroline(p, manvol);                  pnode_printmacroline(p, manvol);
         else  
                 puts("1");  
   
         puts(".Os");          puts(".Os");
 }  }
Line 991  pnode_printfuncdef(struct parse *p, struct pnode *pn)
Line 655  pnode_printfuncdef(struct parse *p, struct pnode *pn)
 {  {
         struct pnode    *pp, *ftype, *func;          struct pnode    *pp, *ftype, *func;
   
           assert(p->newln);
         ftype = func = NULL;          ftype = func = NULL;
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_TEXT == pp->node)                  if (NODE_TEXT == pp->node)
Line 999  pnode_printfuncdef(struct parse *p, struct pnode *pn)
Line 664  pnode_printfuncdef(struct parse *p, struct pnode *pn)
                         func = pp;                          func = pp;
   
         if (NULL != ftype) {          if (NULL != ftype) {
                 fputs(".Ft ", stdout);                  fputs(".Ft", stdout);
                   p->newln = 0;
                 pnode_printmacroline(p, ftype);                  pnode_printmacroline(p, ftype);
         }          }
   
         if (NULL != func) {          if (NULL != func) {
                 fputs(".Fo ", stdout);                  fputs(".Fo", stdout);
                   p->newln = 0;
                 pnode_printmacroline(p, func);                  pnode_printmacroline(p, func);
         } else          } else {
                 puts(".Fo UNKNOWN");                  puts(".Fo UNKNOWN");
                   p->newln = 1;
           }
 }  }
   
 static void  static void
Line 1015  pnode_printparamdef(struct parse *p, struct pnode *pn)
Line 684  pnode_printparamdef(struct parse *p, struct pnode *pn)
 {  {
         struct pnode    *pp, *ptype, *param;          struct pnode    *pp, *ptype, *param;
   
           assert(p->newln);
         ptype = param = NULL;          ptype = param = NULL;
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_TEXT == pp->node)                  if (NODE_TEXT == pp->node)
Line 1023  pnode_printparamdef(struct parse *p, struct pnode *pn)
Line 693  pnode_printparamdef(struct parse *p, struct pnode *pn)
                         param = pp;                          param = pp;
   
         fputs(".Fa \"", stdout);          fputs(".Fa \"", stdout);
           p->newln = 0;
         if (NULL != ptype) {          if (NULL != ptype) {
                 pnode_printmacrolinepart(p, ptype);                  pnode_printmacrolinepart(p, ptype);
                 putchar(' ');                  putchar(' ');
Line 1032  pnode_printparamdef(struct parse *p, struct pnode *pn)
Line 703  pnode_printparamdef(struct parse *p, struct pnode *pn)
                 pnode_printmacrolinepart(p, param);                  pnode_printmacrolinepart(p, param);
   
         puts("\"");          puts("\"");
           p->newln = 1;
 }  }
   
 static void  static void
Line 1039  pnode_printfuncprototype(struct parse *p, struct pnode
Line 711  pnode_printfuncprototype(struct parse *p, struct pnode
 {  {
         struct pnode    *pp, *fdef;          struct pnode    *pp, *fdef;
   
           assert(p->newln);
         TAILQ_FOREACH(fdef, &pn->childq, child)          TAILQ_FOREACH(fdef, &pn->childq, child)
                 if (NODE_FUNCDEF == fdef->node)                  if (NODE_FUNCDEF == fdef->node)
                         break;                          break;
Line 1053  pnode_printfuncprototype(struct parse *p, struct pnode
Line 726  pnode_printfuncprototype(struct parse *p, struct pnode
                         pnode_printparamdef(p, pp);                          pnode_printparamdef(p, pp);
   
         puts(".Fc");          puts(".Fc");
           p->newln = 1;
 }  }
   
 /*  /*
Line 1082  pnode_printarg(struct parse *p, struct pnode *pn)
Line 756  pnode_printarg(struct parse *p, struct pnode *pn)
   
         if (isop) {          if (isop) {
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Op ", stdout);                  fputs("Op", stdout);
         }          }
   
         TAILQ_FOREACH(pp, &pn->childq, child) {          TAILQ_FOREACH(pp, &pn->childq, child) {
                 if (NODE_TEXT == pp->node) {                  if (NODE_TEXT == pp->node) {
                         pnode_printmopen(p);                          pnode_printmopen(p);
                         fputs("Ar ", stdout);                          fputs("Ar", stdout);
                 }                  }
                 pnode_print(p, pp);                  pnode_print(p, pp);
                 if (NODE_TEXT == pp->node && isrep)                  if (NODE_TEXT == pp->node && isrep)
Line 1134  pnode_printprologue(struct parse *p, struct pnode *pn)
Line 808  pnode_printprologue(struct parse *p, struct pnode *pn)
         }          }
 }  }
   
   static void
   pnode_printvarlistentry(struct parse *p, struct pnode *pn)
   {
           struct pnode    *pp;
   
           assert(p->newln);
           TAILQ_FOREACH(pp, &pn->childq, child)
                   if (NODE_TERM == pp->node) {
                           fputs(".It", stdout);
                           p->newln = 0;
                           pnode_print(p, pp);
                           pnode_unlink(pp);
                           putchar('\n');
                           p->newln = 1;
                           return;
                   }
   
           puts(".It");
           p->newln = 1;
   }
   
   static void
   pnode_printvariablelist(struct parse *p, struct pnode *pn)
   {
           struct pnode    *pp;
   
           assert(p->newln);
           TAILQ_FOREACH(pp, &pn->childq, child)
                   if (NODE_TITLE == pp->node) {
                           puts(".Pp");
                           pnode_print(p, pp);
                           pnode_unlink(pp);
                   }
   
           assert(p->newln);
           puts(".Bl -tag -width Ds");
           TAILQ_FOREACH(pp, &pn->childq, child)
                   if (NODE_VARLISTENTRY != pp->node) {
                           assert(p->newln);
                           fputs(".It", stdout);
                           pnode_printmacroline(p, pp);
                   } else {
                           assert(p->newln);
                           pnode_print(p, pp);
                   }
           assert(p->newln);
           puts(".El");
   }
   
 /*  /*
  * Print a parsed node (or ignore it--whatever).   * Print a parsed node (or ignore it--whatever).
  * This is a recursive function.   * This is a recursive function.
Line 1163  pnode_print(struct parse *p, struct pnode *pn)
Line 886  pnode_print(struct parse *p, struct pnode *pn)
                 break;                  break;
         case (NODE_CODE):          case (NODE_CODE):
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Li ", stdout);                  fputs("Li", stdout);
                 break;                  break;
         case (NODE_COMMAND):          case (NODE_COMMAND):
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Nm ", stdout);                  fputs("Nm", stdout);
                 break;                  break;
           case (NODE_EMPHASIS):
                   pnode_printmopen(p);
                   fputs("Em", stdout);
                   break;
         case (NODE_FUNCTION):          case (NODE_FUNCTION):
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Fn ", stdout);                  fputs("Fn", stdout);
                 break;                  break;
         case (NODE_FUNCPROTOTYPE):          case (NODE_FUNCPROTOTYPE):
                 assert(p->newln);                  assert(p->newln);
Line 1180  pnode_print(struct parse *p, struct pnode *pn)
Line 907  pnode_print(struct parse *p, struct pnode *pn)
                 break;                  break;
         case (NODE_FUNCSYNOPSISINFO):          case (NODE_FUNCSYNOPSISINFO):
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Fd ", stdout);                  fputs("Fd", stdout);
                 break;                  break;
         case (NODE_OPTION):          case (NODE_OPTION):
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Fl ", stdout);                  fputs("Fl", stdout);
                   /* FIXME: bogus leading '-'? */
                 break;                  break;
         case (NODE_PARA):          case (NODE_PARA):
                 assert(p->newln);                  assert(p->newln);
                   if (NULL != pn->parent &&
                           NODE_LISTITEM == pn->parent->node)
                           break;
                 puts(".Pp");                  puts(".Pp");
                 break;                  break;
         case (NODE_PARAMETER):          case (NODE_PARAMETER):
Line 1208  pnode_print(struct parse *p, struct pnode *pn)
Line 939  pnode_print(struct parse *p, struct pnode *pn)
         case (NODE_REFNAME):          case (NODE_REFNAME):
                 /* Suppress non-text children... */                  /* Suppress non-text children... */
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Nm ", stdout);                  fputs("Nm", stdout);
                   p->newln = 0;
                 pnode_printmacrolinepart(p, pn);                  pnode_printmacrolinepart(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
Line 1218  pnode_print(struct parse *p, struct pnode *pn)
Line 950  pnode_print(struct parse *p, struct pnode *pn)
                 break;                  break;
         case (NODE_REFPURPOSE):          case (NODE_REFPURPOSE):
                 assert(p->newln);                  assert(p->newln);
                 fputs(".Nd ", stdout);                  pnode_printmopen(p);
                   fputs("Nd", stdout);
                 break;                  break;
         case (NODE_REFSYNOPSISDIV):          case (NODE_REFSYNOPSISDIV):
                 assert(p->newln);                  assert(p->newln);
Line 1229  pnode_print(struct parse *p, struct pnode *pn)
Line 962  pnode_print(struct parse *p, struct pnode *pn)
                 assert(p->newln);                  assert(p->newln);
                 pnode_printrefsect(p, pn);                  pnode_printrefsect(p, pn);
                 break;                  break;
           case (NODE_REPLACEABLE):
                   pnode_printmopen(p);
                   fputs("Ar", stdout);
                   break;
         case (NODE_STRUCTNAME):          case (NODE_STRUCTNAME):
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Vt ", stdout);                  fputs("Vt", stdout);
                 break;                  break;
         case (NODE_TEXT):          case (NODE_TEXT):
                   if (0 == p->newln)
                           putchar(' ');
                 bufclear(p);                  bufclear(p);
                 bufappend(p, pn);                  bufappend(p, pn);
                 /*                  /*
Line 1260  pnode_print(struct parse *p, struct pnode *pn)
Line 999  pnode_print(struct parse *p, struct pnode *pn)
                 }                  }
                 p->newln = 0;                  p->newln = 0;
                 break;                  break;
           case (NODE_VARIABLELIST):
                   assert(p->newln);
                   pnode_printvariablelist(p, pn);
                   pnode_unlinksub(pn);
                   break;
           case (NODE_VARLISTENTRY):
                   assert(p->newln);
                   pnode_printvarlistentry(p, pn);
                   break;
         default:          default:
                 break;                  break;
         }          }
Line 1271  pnode_print(struct parse *p, struct pnode *pn)
Line 1019  pnode_print(struct parse *p, struct pnode *pn)
         case (NODE_ARG):          case (NODE_ARG):
         case (NODE_CODE):          case (NODE_CODE):
         case (NODE_COMMAND):          case (NODE_COMMAND):
           case (NODE_EMPHASIS):
         case (NODE_FUNCTION):          case (NODE_FUNCTION):
         case (NODE_FUNCSYNOPSISINFO):          case (NODE_FUNCSYNOPSISINFO):
         case (NODE_OPTION):          case (NODE_OPTION):
         case (NODE_PARAMETER):          case (NODE_PARAMETER):
           case (NODE_REPLACEABLE):
           case (NODE_REFPURPOSE):
         case (NODE_STRUCTNAME):          case (NODE_STRUCTNAME):
         case (NODE_TEXT):          case (NODE_TEXT):
                 pnode_printmclose(p, sv);                  pnode_printmclose(p, sv);
Legend:
Removed from v.1.12  
changed lines
  Added in v.1.13
CVSweb