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

Diff for /docbook2mdoc/docbook2mdoc.c between version 1.129 and 1.130

version 1.129, 2019/04/15 19:15:19 version 1.130, 2019/04/16 14:26:27
Line 141  pnode_printimagedata(struct format *f, struct pnode *n
Line 141  pnode_printimagedata(struct format *f, struct pnode *n
 }  }
   
 static void  static void
 pnode_printpara(struct format *f, struct pnode *n)  
 {  
         struct pnode    *np;  
   
         if (n->parent == NULL)  
                 return;  
   
         if ((np = TAILQ_PREV(n, pnodeq, child)) == NULL)  
             np = n->parent;  
   
         f->flags = 0;  
   
         switch (np->node) {  
         case NODE_ENTRY:  
         case NODE_FOOTNOTE:  
         case NODE_GLOSSTERM:  
         case NODE_LISTITEM:  
         case NODE_TERM:  
                 return;  
         case NODE_APPENDIX:  
         case NODE_LEGALNOTICE:  
         case NODE_PREFACE:  
         case NODE_SECTION:  
                 if (f->level < 3)  
                         return;  
                 break;  
         default:  
                 break;  
         }  
         macro_line(f, "Pp");  
 }  
   
 static void  
 pnode_printrefnamediv(struct format *f, struct pnode *n)  pnode_printrefnamediv(struct format *f, struct pnode *n)
 {  {
         struct pnode    *nc, *nn;          struct pnode    *nc, *nn;
         int              comma;          int              comma;
   
           f->parastate = PARA_HAVE;
         macro_line(f, "Sh NAME");          macro_line(f, "Sh NAME");
           f->parastate = PARA_HAVE;
         comma = 0;          comma = 0;
         TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {          TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
                 if (nc->node != NODE_REFNAME)                  if (nc->node != NODE_REFNAME)
Line 206  pnode_printrefsynopsisdiv(struct format *f, struct pno
Line 175  pnode_printrefsynopsisdiv(struct format *f, struct pno
                 if (nc->node == NODE_TITLE)                  if (nc->node == NODE_TITLE)
                         pnode_unlink(nc);                          pnode_unlink(nc);
   
           f->parastate = PARA_HAVE;
         macro_line(f, "Sh SYNOPSIS");          macro_line(f, "Sh SYNOPSIS");
           f->parastate = PARA_HAVE;
 }  }
   
 /*  /*
Line 280  pnode_printsection(struct format *f, struct pnode *n)
Line 251  pnode_printsection(struct format *f, struct pnode *n)
         switch (level) {          switch (level) {
         case 1:          case 1:
                 macro_close(f);                  macro_close(f);
                   f->parastate = PARA_HAVE;
                 macro_open(f, "Sh");                  macro_open(f, "Sh");
                 break;                  break;
         case 2:          case 2:
                 macro_close(f);                  macro_close(f);
                   f->parastate = PARA_HAVE;
                 macro_open(f, "Ss");                  macro_open(f, "Ss");
                 break;                  break;
         default:          default:
                 pnode_printpara(f, n);                  if (f->parastate == PARA_MID)
                           f->parastate = PARA_WANT;
                 macro_open(f, "Sy");                  macro_open(f, "Sy");
                 break;                  break;
         }          }
Line 304  pnode_printsection(struct format *f, struct pnode *n)
Line 278  pnode_printsection(struct format *f, struct pnode *n)
          */           */
   
         if (nc != NULL) {          if (nc != NULL) {
                 ncc = TAILQ_FIRST(&nc->childq);                  if (level == 1 &&
                 if (ncc != NULL && ncc->node == NODE_TEXT &&                      (ncc = TAILQ_FIRST(&nc->childq)) != NULL &&
                       ncc->node == NODE_TEXT &&
                     strcasecmp(ncc->b, "AUTHORS") == 0)                      strcasecmp(ncc->b, "AUTHORS") == 0)
                         macro_line(f, "An -nosplit");                          macro_line(f, "An -nosplit");
                 pnode_unlink(nc);                  pnode_unlink(nc);
         }          }
           f->parastate = level > 2 ? PARA_WANT : PARA_HAVE;
 }  }
   
 /*  /*
Line 785  pnode_printprologue(struct format *f, struct pnode *ro
Line 761  pnode_printprologue(struct format *f, struct pnode *ro
         pnode_unlink(name);          pnode_unlink(name);
         pnode_unlink(vol);          pnode_unlink(vol);
         pnode_unlink(descr);          pnode_unlink(descr);
           f->parastate = PARA_HAVE;
 }  }
   
 static void  static void
Line 928  pnode_printvarlistentry(struct format *f, struct pnode
Line 905  pnode_printvarlistentry(struct format *f, struct pnode
         int              first = 1;          int              first = 1;
   
         macro_open(f, "It");          macro_open(f, "It");
           f->parastate = PARA_HAVE;
         f->flags |= FMT_IMPL;          f->flags |= FMT_IMPL;
         TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {          TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
                 if (nc->node != NODE_TERM && nc->node != NODE_GLOSSTERM)                  if (nc->node != NODE_TERM && nc->node != NODE_GLOSSTERM)
Line 944  pnode_printvarlistentry(struct format *f, struct pnode
Line 922  pnode_printvarlistentry(struct format *f, struct pnode
                                 break;                                  break;
                         }                          }
                 }                  }
                   f->parastate = PARA_HAVE;
                 pnode_print(f, nc);                  pnode_print(f, nc);
                 pnode_unlink(nc);                  pnode_unlink(nc);
                 first = 0;                  first = 0;
         }          }
         macro_close(f);          macro_close(f);
           f->parastate = PARA_HAVE;
         while ((nc = TAILQ_FIRST(&n->childq)) != NULL) {          while ((nc = TAILQ_FIRST(&n->childq)) != NULL) {
                 pnode_print(f, nc);                  pnode_print(f, nc);
                 pnode_unlink(nc);                  pnode_unlink(nc);
         }          }
         macro_close(f);          macro_close(f);
           f->parastate = PARA_HAVE;
 }  }
   
 static void  static void
Line 963  pnode_printtitle(struct format *f, struct pnode *n)
Line 944  pnode_printtitle(struct format *f, struct pnode *n)
   
         TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {          TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
                 if (nc->node == NODE_TITLE) {                  if (nc->node == NODE_TITLE) {
                         pnode_printpara(f, nc);                          if (f->parastate == PARA_MID)
                         pnode_print(f, nc);                                  f->parastate = PARA_WANT;
                           macro_nodeline(f, "Sy", nc, 0);
                         pnode_unlink(nc);                          pnode_unlink(nc);
                 }                  }
         }          }
Line 992  pnode_printtgroup1(struct format *f, struct pnode *n)
Line 974  pnode_printtgroup1(struct format *f, struct pnode *n)
         macro_line(f, "Bl -bullet -compact");          macro_line(f, "Bl -bullet -compact");
         while ((nc = pnode_findfirst(n, NODE_ENTRY)) != NULL) {          while ((nc = pnode_findfirst(n, NODE_ENTRY)) != NULL) {
                 macro_line(f, "It");                  macro_line(f, "It");
                   f->parastate = PARA_HAVE;
                 pnode_print(f, nc);                  pnode_print(f, nc);
                   f->parastate = PARA_HAVE;
                 pnode_unlink(nc);                  pnode_unlink(nc);
         }          }
         macro_line(f, "El");          macro_line(f, "El");
Line 1004  pnode_printtgroup2(struct format *f, struct pnode *n)
Line 988  pnode_printtgroup2(struct format *f, struct pnode *n)
 {  {
         struct pnode    *nr, *ne;          struct pnode    *nr, *ne;
   
           f->parastate = PARA_HAVE;
         macro_line(f, "Bl -tag -width Ds");          macro_line(f, "Bl -tag -width Ds");
         while ((nr = pnode_findfirst(n, NODE_ROW)) != NULL) {          while ((nr = pnode_findfirst(n, NODE_ROW)) != NULL) {
                 if ((ne = pnode_findfirst(n, NODE_ENTRY)) == NULL)                  if ((ne = pnode_findfirst(n, NODE_ENTRY)) == NULL)
                         break;                          break;
                 macro_open(f, "It");                  macro_open(f, "It");
                 f->flags |= FMT_IMPL;                  f->flags |= FMT_IMPL;
                   f->parastate = PARA_HAVE;
                 pnode_print(f, ne);                  pnode_print(f, ne);
                 macro_close(f);                  macro_close(f);
                 pnode_unlink(ne);                  pnode_unlink(ne);
                   f->parastate = PARA_HAVE;
                 pnode_print(f, nr);                  pnode_print(f, nr);
                   f->parastate = PARA_HAVE;
                 pnode_unlink(nr);                  pnode_unlink(nr);
         }          }
         macro_line(f, "El");          macro_line(f, "El");
Line 1036  pnode_printtgroup(struct format *f, struct pnode *n)
Line 1024  pnode_printtgroup(struct format *f, struct pnode *n)
                 break;                  break;
         }          }
   
           f->parastate = PARA_HAVE;
         macro_line(f, "Bl -ohang");          macro_line(f, "Bl -ohang");
         while ((nc = pnode_findfirst(n, NODE_ROW)) != NULL) {          while ((nc = pnode_findfirst(n, NODE_ROW)) != NULL) {
                 macro_line(f, "It Table Row");                  macro_line(f, "It Table Row");
Line 1051  pnode_printlist(struct format *f, struct pnode *n)
Line 1040  pnode_printlist(struct format *f, struct pnode *n)
         struct pnode    *nc;          struct pnode    *nc;
   
         pnode_printtitle(f, n);          pnode_printtitle(f, n);
           f->parastate = PARA_HAVE;
         macro_argline(f, "Bl",          macro_argline(f, "Bl",
             n->node == NODE_ORDEREDLIST ? "-enum" : "-bullet");              n->node == NODE_ORDEREDLIST ? "-enum" : "-bullet");
         TAILQ_FOREACH(nc, &n->childq, child) {          TAILQ_FOREACH(nc, &n->childq, child) {
                 macro_line(f, "It");                  macro_line(f, "It");
                   f->parastate = PARA_HAVE;
                 pnode_print(f, nc);                  pnode_print(f, nc);
                   f->parastate = PARA_HAVE;
         }          }
         macro_line(f, "El");          macro_line(f, "El");
         pnode_unlinksub(n);          pnode_unlinksub(n);
Line 1067  pnode_printvariablelist(struct format *f, struct pnode
Line 1059  pnode_printvariablelist(struct format *f, struct pnode
         struct pnode    *nc;          struct pnode    *nc;
   
         pnode_printtitle(f, n);          pnode_printtitle(f, n);
           f->parastate = PARA_HAVE;
         macro_line(f, "Bl -tag -width Ds");          macro_line(f, "Bl -tag -width Ds");
         TAILQ_FOREACH(nc, &n->childq, child) {          TAILQ_FOREACH(nc, &n->childq, child) {
                 if (nc->node == NODE_VARLISTENTRY)                  if (nc->node == NODE_VARLISTENTRY)
Line 1110  pnode_print(struct format *f, struct pnode *n)
Line 1103  pnode_print(struct format *f, struct pnode *n)
                 macro_line(f, "An -split");                  macro_line(f, "An -split");
                 break;                  break;
         case NODE_BLOCKQUOTE:          case NODE_BLOCKQUOTE:
                   f->parastate = PARA_HAVE;
                 macro_line(f, "Bd -ragged -offset indent");                  macro_line(f, "Bd -ragged -offset indent");
                   f->parastate = PARA_HAVE;
                 break;                  break;
         case NODE_CITEREFENTRY:          case NODE_CITEREFENTRY:
                 pnode_printciterefentry(f, n);                  pnode_printciterefentry(f, n);
Line 1146  pnode_print(struct format *f, struct pnode *n)
Line 1141  pnode_print(struct format *f, struct pnode *n)
                 if ((nc = TAILQ_FIRST(&n->childq)) != NULL &&                  if ((nc = TAILQ_FIRST(&n->childq)) != NULL &&
                     pnode_class(nc->node) < CLASS_LINE)                      pnode_class(nc->node) < CLASS_LINE)
                         macro_open(f, "Em");                          macro_open(f, "Em");
                   if (n->node == NODE_GLOSSTERM)
                           f->parastate = PARA_HAVE;
                 break;                  break;
         case NODE_ENVAR:          case NODE_ENVAR:
                 macro_open(f, "Ev");                  macro_open(f, "Ev");
Line 1158  pnode_print(struct format *f, struct pnode *n)
Line 1155  pnode_print(struct format *f, struct pnode *n)
                 break;                  break;
         case NODE_FOOTNOTE:          case NODE_FOOTNOTE:
                 macro_line(f, "Bo");                  macro_line(f, "Bo");
                   f->parastate = PARA_HAVE;
                 break;                  break;
         case NODE_FUNCTION:          case NODE_FUNCTION:
                 macro_open(f, "Fn");                  macro_open(f, "Fn");
Line 1172  pnode_print(struct format *f, struct pnode *n)
Line 1170  pnode_print(struct format *f, struct pnode *n)
                 pnode_printimagedata(f, n);                  pnode_printimagedata(f, n);
                 break;                  break;
         case NODE_INFORMALEQUATION:          case NODE_INFORMALEQUATION:
                   f->parastate = PARA_HAVE;
                 macro_line(f, "Bd -ragged -offset indent");                  macro_line(f, "Bd -ragged -offset indent");
                   f->parastate = PARA_HAVE;
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case NODE_INLINEEQUATION:          case NODE_INLINEEQUATION:
                 macro_line(f, "EQ");                  macro_line(f, "EQ");
Line 1201  pnode_print(struct format *f, struct pnode *n)
Line 1201  pnode_print(struct format *f, struct pnode *n)
                 break;                  break;
         case NODE_LITERALLAYOUT:          case NODE_LITERALLAYOUT:
                 macro_close(f);                  macro_close(f);
                   f->parastate = PARA_HAVE;
                 macro_argline(f, "Bd", pnode_getattr(n, ATTRKEY_CLASS) ==                  macro_argline(f, "Bd", pnode_getattr(n, ATTRKEY_CLASS) ==
                     ATTRVAL_MONOSPACED ? "-literal" : "-unfilled");                      ATTRVAL_MONOSPACED ? "-literal" : "-unfilled");
                   f->parastate = PARA_HAVE;
                 break;                  break;
         case NODE_MARKUP:          case NODE_MARKUP:
                 macro_open(f, "Ic");                  macro_open(f, "Ic");
Line 1235  pnode_print(struct format *f, struct pnode *n)
Line 1237  pnode_print(struct format *f, struct pnode *n)
                 pnode_printlist(f, n);                  pnode_printlist(f, n);
                 break;                  break;
         case NODE_PARA:          case NODE_PARA:
                 pnode_printpara(f, n);                  if (f->parastate == PARA_MID)
                           f->parastate = PARA_WANT;
                 break;                  break;
         case NODE_PARAMDEF:          case NODE_PARAMDEF:
         case NODE_PARAMETER:          case NODE_PARAMETER:
Line 1260  pnode_print(struct format *f, struct pnode *n)
Line 1263  pnode_print(struct format *f, struct pnode *n)
         case NODE_PROGRAMLISTING:          case NODE_PROGRAMLISTING:
         case NODE_SCREEN:          case NODE_SCREEN:
         case NODE_SYNOPSIS:          case NODE_SYNOPSIS:
                   f->parastate = PARA_HAVE;
                 macro_line(f, "Bd -literal");                  macro_line(f, "Bd -literal");
                   f->parastate = PARA_HAVE;
                 break;                  break;
         case NODE_SYSTEMITEM:          case NODE_SYSTEMITEM:
                 pnode_printsystemitem(f, n);                  pnode_printsystemitem(f, n);
Line 1296  pnode_print(struct format *f, struct pnode *n)
Line 1301  pnode_print(struct format *f, struct pnode *n)
                 macro_open(f, "Ar");                  macro_open(f, "Ar");
                 break;                  break;
         case NODE_SBR:          case NODE_SBR:
                 macro_line(f, "br");                  if (f->parastate == PARA_MID)
                           macro_line(f, "br");
                 break;                  break;
         case NODE_SUBSCRIPT:          case NODE_SUBSCRIPT:
                 if (f->linestate == LINE_MACRO)                  if (f->linestate == LINE_MACRO)
Line 1320  pnode_print(struct format *f, struct pnode *n)
Line 1326  pnode_print(struct format *f, struct pnode *n)
                 break;                  break;
         case NODE_TITLE:          case NODE_TITLE:
         case NODE_SUBTITLE:          case NODE_SUBTITLE:
                 pnode_printpara(f, n);                  if (f->parastate == PARA_MID)
                           f->parastate = PARA_WANT;
                 macro_nodeline(f, "Sy", n, 0);                  macro_nodeline(f, "Sy", n, 0);
                 pnode_unlinksub(n);                  pnode_unlinksub(n);
                 break;                  break;
Line 1357  pnode_print(struct format *f, struct pnode *n)
Line 1364  pnode_print(struct format *f, struct pnode *n)
                 /* Accept more arguments to the previous macro. */                  /* Accept more arguments to the previous macro. */
                 return;                  return;
         case NODE_FOOTNOTE:          case NODE_FOOTNOTE:
                   f->parastate = PARA_HAVE;
                 macro_line(f, "Bc");                  macro_line(f, "Bc");
                 break;                  break;
           case NODE_GLOSSTERM:
                   f->parastate = PARA_HAVE;
                   break;
         case NODE_INFORMALEQUATION:          case NODE_INFORMALEQUATION:
                 macro_line(f, "EN");                  macro_line(f, "EN");
                 macro_line(f, "Ed");                  macro_line(f, "Ed");
Line 1401  pnode_print(struct format *f, struct pnode *n)
Line 1412  pnode_print(struct format *f, struct pnode *n)
                         break;                          break;
                 fputs(" } ", stdout);                  fputs(" } ", stdout);
                 break;                  break;
           case NODE_PARA:
                   if (f->parastate == PARA_MID)
                           f->parastate = PARA_WANT;
                   break;
         case NODE_QUOTE:          case NODE_QUOTE:
                 if ((nc = TAILQ_FIRST(&n->childq)) != NULL &&                  if ((nc = TAILQ_FIRST(&n->childq)) != NULL &&
                     nc->node == NODE_FILENAME &&                      nc->node == NODE_FILENAME &&
Line 1427  pnode_print(struct format *f, struct pnode *n)
Line 1442  pnode_print(struct format *f, struct pnode *n)
         case NODE_PROGRAMLISTING:          case NODE_PROGRAMLISTING:
         case NODE_SCREEN:          case NODE_SCREEN:
         case NODE_SYNOPSIS:          case NODE_SYNOPSIS:
                   f->parastate = PARA_HAVE;
                 macro_line(f, "Ed");                  macro_line(f, "Ed");
                 break;                  break;
           case NODE_TITLE:
           case NODE_SUBTITLE:
                   f->parastate = PARA_WANT;
                   break;
         default:          default:
                 break;                  break;
         }          }
Line 1442  ptree_print_mdoc(struct ptree *tree)
Line 1462  ptree_print_mdoc(struct ptree *tree)
   
         formatter.level = 0;          formatter.level = 0;
         formatter.linestate = LINE_NEW;          formatter.linestate = LINE_NEW;
           formatter.parastate = PARA_HAVE;
         pnode_printprologue(&formatter, tree->root);          pnode_printprologue(&formatter, tree->root);
         pnode_print(&formatter, tree->root);          pnode_print(&formatter, tree->root);
         if (formatter.linestate != LINE_NEW)          if (formatter.linestate != LINE_NEW)
Legend:
Removed from v.1.129  
changed lines
  Added in v.1.130
CVSweb